stdlib_linalg_lapack Module



Contents

bbcsd bdsdc bdsqr disna gbbrd gbcon gbequ gbequb gbrfs gbsv gbtrf gbtrs gebak gebal gebrd gecon geequ geequb gees geev gehrd gejsv gelq gelqf gelqt gelqt3 gels gelsd gelss gelsy gemlq gemlqt gemqr gemqrt geqlf geqr geqr2p geqrf geqrfp geqrt geqrt2 geqrt3 gerfs gerqf gesdd gesv gesvd gesvdq gesvj getrf getrf2 getri getrs getsls getsqrhrt ggbak ggbal gges ggev ggglm gghrd gglse ggqrf ggrqf gsvj0 gsvj1 gtcon gtrfs gtsv gttrf gttrs hb2st_kernels hbev hbevd hbgst hbgv hbgvd hbtrd hecon hecon_rook heequb heev heevd heevr hegst hegv hegvd herfs hesv hesv_aa hesv_rk hesv_rook heswapr hetf2_rk hetf2_rook hetrd hetrd_hb2st hetrd_he2hb hetrf hetrf_aa hetrf_rk hetrf_rook hetri hetri_rook hetrs hetrs2 hetrs_3 hetrs_aa hetrs_rook hfrk hgeqz hpcon hpev hpevd hpgst hpgv hpgvd hprfs hpsv hptrd hptrf hptri hptrs hsein hseqr isnan la_gbamv la_gbrcond la_gbrcond_c la_gbrpvgrw la_geamv la_gercond la_gercond_c la_gerpvgrw la_heamv la_hercond_c la_herpvgrw la_lin_berr la_porcond la_porcond_c la_porpvgrw la_syamv la_syrcond la_syrcond_c la_syrpvgrw la_wwaddw labad labrd lacgv lacon lacpy lacrm lacrt ladiv1 ladiv2 ladiv_f ladiv_s laebz laed0 laed1 laed4 laed5 laed6 laed7 laed8 laed9 laeda laein laesy laexc lagtf lagtm lagts lahef lahef_aa lahef_rk lahef_rook lahqr laic1 laisnan lals0 lalsa lalsd lamrg lamswlq lamtsqr laneg langb lange langt lanhb lanhe lanhf lanhp lanhs lanht lansb lansf lansp lanst lansy lantb lantp lantr laorhr_col_getrfnp laorhr_col_getrfnp2 lapll lapmr lapmt laqgb laqge laqhb laqhe laqhp laqps laqr0 laqr1 laqr4 laqr5 laqsb laqsp laqsy laqtr laqz0 laqz1 laqz4 lar1v lar2v larcm larf larfb larfb_gett larfg larfgp larft larfy largv larnv larra larrb larrc larrd larre larrf larrj larrk larrr larrv lartg lartgp lartgs lartv laruv larz larzb larzt lascl lasd0 lasd1 lasd4 lasd5 lasd6 lasd7 lasd8 lasda lasdq laset lasq1 lasq4 lasq5 lasq6 lasr lasrt lassq laswlq laswp lasyf lasyf_aa lasyf_rk lasyf_rook latbs latdf latps latrd latrs latrz latsqr launhr_col_getrfnp launhr_col_getrfnp2 lauum opgtr opmtr orbdb orbdb1 orbdb2 orbdb3 orbdb4 orbdb5 orbdb6 orcsd orcsd2by1 org2l org2r orgbr orghr orglq orgql orgqr orgrq orgtr orgtsqr orgtsqr_row orhr_col orm2l orm2r ormbr ormhr ormlq ormql ormqr ormrq ormrz ormtr pbcon pbequ pbrfs pbstf pbsv pbtrf pbtrs pftrf pftri pftrs pocon poequ poequb porfs posv potrf potrf2 potri potrs ppcon ppequ pprfs ppsv pptrf pptri pptrs pstrf ptcon pteqr ptrfs ptsv pttrf pttrs rot rscl sb2st_kernels sbev sbevd sbgst sbgv sbgvd sbtrd sfrk spcon spev spevd spgst spgv spgvd spmv spr sprfs spsv sptrd sptrf sptri sptrs stebz stedc stegr stein stemr steqr sterf stev stevd stevr sycon sycon_rook syconv syconvf syconvf_rook syequb syev syevd syevr sygst sygv sygvd symv syr syrfs sysv sysv_aa sysv_rk sysv_rook syswapr sytf2_rk sytf2_rook sytrd sytrd_sb2st sytrd_sy2sb sytrf sytrf_aa sytrf_rk sytrf_rook sytri sytri_rook sytrs sytrs2 sytrs_3 sytrs_aa sytrs_rook tbcon tbrfs tbtrs tfsm tftri tfttp tfttr tgevc tgexc tgsen tgsja tgsna tgsyl tpcon tplqt tplqt2 tpmlqt tpmqrt tpqrt tpqrt2 tprfb tprfs tptri tptrs tpttf tpttr trcon trevc trevc3 trexc trrfs trsen trsna trsyl trtri trtrs trttf trttp tzrzf unbdb unbdb1 unbdb2 unbdb3 unbdb4 unbdb5 unbdb6 uncsd uncsd2by1 ung2l ung2r ungbr unghr unglq ungql ungqr ungrq ungtr ungtsqr ungtsqr_row unhr_col unm2l unm2r unmbr unmhr unmlq unmql unmqr unmrq unmrz unmtr upgtr upmtr

Interfaces

public interface bbcsd

BBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

  • public pure subroutine cbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: theta(*)
    real(kind=sp), intent(inout) :: phi(*)
    complex(kind=sp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: b11d(*)
    real(kind=sp), intent(out) :: b11e(*)
    real(kind=sp), intent(out) :: b12d(*)
    real(kind=sp), intent(out) :: b12e(*)
    real(kind=sp), intent(out) :: b21d(*)
    real(kind=sp), intent(out) :: b21e(*)
    real(kind=sp), intent(out) :: b22d(*)
    real(kind=sp), intent(out) :: b22e(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: theta(*)
    real(kind=dp), intent(inout) :: phi(*)
    real(kind=dp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: b11d(*)
    real(kind=dp), intent(out) :: b11e(*)
    real(kind=dp), intent(out) :: b12d(*)
    real(kind=dp), intent(out) :: b12e(*)
    real(kind=dp), intent(out) :: b21d(*)
    real(kind=dp), intent(out) :: b21e(*)
    real(kind=dp), intent(out) :: b22d(*)
    real(kind=dp), intent(out) :: b22e(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: theta(*)
    real(kind=sp), intent(inout) :: phi(*)
    real(kind=sp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: b11d(*)
    real(kind=sp), intent(out) :: b11e(*)
    real(kind=sp), intent(out) :: b12d(*)
    real(kind=sp), intent(out) :: b12e(*)
    real(kind=sp), intent(out) :: b21d(*)
    real(kind=sp), intent(out) :: b21e(*)
    real(kind=sp), intent(out) :: b22d(*)
    real(kind=sp), intent(out) :: b22e(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: theta(*)
    real(kind=dp), intent(inout) :: phi(*)
    complex(kind=dp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: b11d(*)
    real(kind=dp), intent(out) :: b11e(*)
    real(kind=dp), intent(out) :: b12d(*)
    real(kind=dp), intent(out) :: b12e(*)
    real(kind=dp), intent(out) :: b21d(*)
    real(kind=dp), intent(out) :: b21e(*)
    real(kind=dp), intent(out) :: b22d(*)
    real(kind=dp), intent(out) :: b22e(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info)

    CBBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: theta(*)
    real(kind=sp), intent(inout) :: phi(*)
    complex(kind=sp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: b11d(*)
    real(kind=sp), intent(out) :: b11e(*)
    real(kind=sp), intent(out) :: b12d(*)
    real(kind=sp), intent(out) :: b12e(*)
    real(kind=sp), intent(out) :: b21d(*)
    real(kind=sp), intent(out) :: b21e(*)
    real(kind=sp), intent(out) :: b22d(*)
    real(kind=sp), intent(out) :: b22e(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info)

    DBBCSD computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: theta(*)
    real(kind=dp), intent(inout) :: phi(*)
    real(kind=dp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: b11d(*)
    real(kind=dp), intent(out) :: b11e(*)
    real(kind=dp), intent(out) :: b12d(*)
    real(kind=dp), intent(out) :: b12e(*)
    real(kind=dp), intent(out) :: b21d(*)
    real(kind=dp), intent(out) :: b21e(*)
    real(kind=dp), intent(out) :: b22d(*)
    real(kind=dp), intent(out) :: b22e(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info)

    SBBCSD computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: theta(*)
    real(kind=sp), intent(inout) :: phi(*)
    real(kind=sp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: b11d(*)
    real(kind=sp), intent(out) :: b11e(*)
    real(kind=sp), intent(out) :: b12d(*)
    real(kind=sp), intent(out) :: b12e(*)
    real(kind=sp), intent(out) :: b21d(*)
    real(kind=sp), intent(out) :: b21e(*)
    real(kind=sp), intent(out) :: b22d(*)
    real(kind=sp), intent(out) :: b22e(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info)

    ZBBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: theta(*)
    real(kind=dp), intent(inout) :: phi(*)
    complex(kind=dp), intent(inout) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(inout) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(inout) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(inout) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: b11d(*)
    real(kind=dp), intent(out) :: b11e(*)
    real(kind=dp), intent(out) :: b12d(*)
    real(kind=dp), intent(out) :: b12e(*)
    real(kind=dp), intent(out) :: b21d(*)
    real(kind=dp), intent(out) :: b21e(*)
    real(kind=dp), intent(out) :: b22d(*)
    real(kind=dp), intent(out) :: b22e(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info

public interface bdsdc

BDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. BDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLASD3 for details. The code currently calls DLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.

  • public pure subroutine dbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: q(*)
    integer(kind=ilp), intent(out) :: iq(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: q(*)
    integer(kind=ilp), intent(out) :: iq(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info)

    DBDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. DBDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLASD3 for details. The code currently calls DLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: q(*)
    integer(kind=ilp), intent(out) :: iq(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info)

    SBDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. SBDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLASD3 for details. The code currently calls SLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: q(*)
    integer(kind=ilp), intent(out) :: iq(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface bdsqr

BDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by CGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

  • public pure subroutine cbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)

    CBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by CGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    DBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PT where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PTVT instead of PT, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by DGEBRD, then A = (UQ) * S * (PT*VT) is the SVD of A. Optionally, the subroutine may also compute QT*C for a given real input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    SBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PT where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PTVT instead of PT, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by SGEBRD, then A = (UQ) * S * (PT*VT) is the SVD of A. Optionally, the subroutine may also compute QT*C for a given real input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)

    ZBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by ZGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface disna

DISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.

  • public pure subroutine ddisna(job, m, n, d, sep, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sdisna(job, m, n, d, sep, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ddisna(job, m, n, d, sep, info)

    DDISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sdisna(job, m, n, d, sep, info)

    SDISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by SLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than SLAMCH( 'E' )*ANORM in order to limit the size of the error bound. SDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(out) :: info

public interface gbbrd

GBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.

  • public pure subroutine cgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info)

    CGBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info)

    DGBBRD reduces a real general m-by-n band matrix A to upper bidiagonal form B by an orthogonal transformation: QT * A * P = B. The routine computes B, and optionally forms Q or PT, or computes Q*TC for a given matrix C.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info)

    SGBBRD reduces a real general m-by-n band matrix A to upper bidiagonal form B by an orthogonal transformation: QT * A * P = B. The routine computes B, and optionally forms Q or PT, or computes Q*TC for a given matrix C.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info)

    ZGBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncc
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: pt(ldpt,*)
    integer(kind=ilp), intent(in) :: ldpt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gbcon

GBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

  • public pure subroutine cgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)

    CGBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info)

    DGBCON estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info)

    SGBCON estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)

    ZGBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gbequ

GBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

  • public pure subroutine cgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    CGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    DGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    SGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    ZGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface gbequb

GBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

  • public pure subroutine cgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    CGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    DGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    SGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)

    ZGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface gbrfs

GBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gbsv

GBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    CGBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    DGBSV computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    SGBSV computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    ZGBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface gbtrf

GBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine cgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    CGBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    DGBTRF computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    SGBTRF computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbtrf(m, n, kl, ku, ab, ldab, ipiv, info)

    ZGBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface gbtrs

GBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by CGBTRF.

  • public pure subroutine cgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    CGBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by CGBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    DGBTRS solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    SGBTRS solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by SGBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)

    ZGBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface gebak

GEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.

  • public pure subroutine cgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    CGEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    DGEBAK forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by DGEBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    SGEBAK forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by SGEBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)

    ZGEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by ZGEBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: scale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info

public interface gebal

GEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

  • public pure subroutine cgebal(job, n, a, lda, ilo, ihi, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgebal(job, n, a, lda, ilo, ihi, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgebal(job, n, a, lda, ilo, ihi, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgebal(job, n, a, lda, ilo, ihi, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgebal(job, n, a, lda, ilo, ihi, scale, info)

    CGEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgebal(job, n, a, lda, ilo, ihi, scale, info)

    DGEBAL balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgebal(job, n, a, lda, ilo, ihi, scale, info)

    SGEBAL balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgebal(job, n, a, lda, ilo, ihi, scale, info)

    ZGEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: scale(*)
    integer(kind=ilp), intent(out) :: info

public interface gebrd

GEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

  • public pure subroutine cgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tauq(*)
    complex(kind=sp), intent(out) :: taup(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tauq(*)
    real(kind=dp), intent(out) :: taup(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tauq(*)
    real(kind=sp), intent(out) :: taup(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tauq(*)
    complex(kind=dp), intent(out) :: taup(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    CGEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tauq(*)
    complex(kind=sp), intent(out) :: taup(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    DGEBRD reduces a general real M-by-N matrix A to upper or lower bidiagonal form B by an orthogonal transformation: Q**T * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tauq(*)
    real(kind=dp), intent(out) :: taup(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    SGEBRD reduces a general real M-by-N matrix A to upper or lower bidiagonal form B by an orthogonal transformation: Q**T * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tauq(*)
    real(kind=sp), intent(out) :: taup(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info)

    ZGEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tauq(*)
    complex(kind=dp), intent(out) :: taup(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gecon

GECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

  • public pure subroutine cgecon(norm, n, a, lda, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgecon(norm, n, a, lda, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgecon(norm, n, a, lda, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgecon(norm, n, a, lda, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgecon(norm, n, a, lda, anorm, rcond, work, rwork, info)

    CGECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgecon(norm, n, a, lda, anorm, rcond, work, iwork, info)

    DGECON estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgecon(norm, n, a, lda, anorm, rcond, work, iwork, info)

    SGECON estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgecon(norm, n, a, lda, anorm, rcond, work, rwork, info)

    ZGECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface geequ

GEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

  • public pure subroutine cgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    CGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    DGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    SGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    ZGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface geequb

GEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

  • public pure subroutine cgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    CGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    DGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    SGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: r(*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: rowcnd
    real(kind=sp), intent(out) :: colcnd
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)

    ZGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: r(*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: rowcnd
    real(kind=dp), intent(out) :: colcnd
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface gees

GEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.

  • public subroutine cgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_c) :: select
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_d) :: select
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_s) :: select
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_z) :: select
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info)

    CGEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_c) :: select
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info)

    DGEES computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z*T). Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form [ a b ] [ c a ] where bc < 0. The eigenvalues of such a block are a +- sqrt(bc).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_d) :: select
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info)

    SGEES computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z*T). Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form [ a b ] [ c a ] where bc < 0. The eigenvalues of such a block are a +- sqrt(bc).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_s) :: select
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info)

    ZGEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvs
    character, intent(in) :: sort
    procedure(stdlib_select_z) :: select
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: vs(ldvs,*)
    integer(kind=ilp), intent(in) :: ldvs
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info

public interface geev

GEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

  • public subroutine cgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    CGEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info)

    DGEEV computes for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate-transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info)

    SGEEV computes for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate-transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    ZGEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gehrd

GEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

  • public pure subroutine cgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    CGEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    DGEHRD reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    SGEHRD reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)

    ZGEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gejsv

GEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.

  • public pure subroutine cgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(out) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(out) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info)

    CGEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(out) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info)

    DGEJSV computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. DGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info)

    SGEJSV computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. SGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info)

    ZGEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobr
    character, intent(in) :: jobt
    character, intent(in) :: jobp
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(out) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gelq

GELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

  • public pure subroutine cgelq(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgelq(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgelq(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgelq(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgelq(m, n, a, lda, t, tsize, work, lwork, info)

    CGELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgelq(m, n, a, lda, t, tsize, work, lwork, info)

    DGELQ computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgelq(m, n, a, lda, t, tsize, work, lwork, info)

    SGELQ computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgelq(m, n, a, lda, t, tsize, work, lwork, info)

    ZGELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gelqf

GELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

  • public pure subroutine cgelqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgelqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgelqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgelqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgelqf(m, n, a, lda, tau, work, lwork, info)

    CGELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgelqf(m, n, a, lda, tau, work, lwork, info)

    DGELQF computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgelqf(m, n, a, lda, tau, work, lwork, info)

    SGELQF computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgelqf(m, n, a, lda, tau, work, lwork, info)

    ZGELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gelqt

GELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.

  • public pure subroutine cgelqt(m, n, mb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgelqt(m, n, mb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgelqt(m, n, mb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgelqt(m, n, mb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgelqt(m, n, mb, a, lda, t, ldt, work, info)

    CGELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgelqt(m, n, mb, a, lda, t, ldt, work, info)

    DGELQT computes a blocked LQ factorization of a real M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgelqt(m, n, mb, a, lda, t, ldt, work, info)

    DGELQT computes a blocked LQ factorization of a real M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgelqt(m, n, mb, a, lda, t, ldt, work, info)

    ZGELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface gelqt3

GELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

  • public pure recursive subroutine cgelqt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine dgelqt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine sgelqt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine zgelqt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_cgelqt3(m, n, a, lda, t, ldt, info)

    CGELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_dgelqt3(m, n, a, lda, t, ldt, info)

    DGELQT3 recursively computes a LQ factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_sgelqt3(m, n, a, lda, t, ldt, info)

    SGELQT3 recursively computes a LQ factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_zgelqt3(m, n, a, lda, t, ldt, info)

    ZGELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info

public interface gels

GELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

  • public subroutine cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    CGELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    DGELS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, or its transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an underdetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    SGELS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, or its transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an underdetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    ZGELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gelsd

GELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine cgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)

    CGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)

    DGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)

    SGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)

    ZGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gelss

GELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

  • public subroutine cgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)

    CGELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)

    DGELSS computes the minimum norm solution to a real linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)

    SGELSS computes the minimum norm solution to a real linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)

    ZGELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gelsy

GELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.

  • public subroutine cgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)

    CGELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)

    DGELSY computes the minimum-norm solution to a real linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by orthogonal transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZT [ inv(T11)*Q1T*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3. o The permutation of matrix B (the right hand side) is faster and more simple.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)

    SGELSY computes the minimum-norm solution to a real linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by orthogonal transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZT [ inv(T11)*Q1T*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3. o The permutation of matrix B (the right hand side) is faster and more simple.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)

    ZGELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gemlq

GEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)

  • public pure subroutine cgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    CGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    DGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (DGELQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    SGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (SGELQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    ZGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (ZGELQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gemlqt

GEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    CGEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    DGEMLQT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by DGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    DGEMLQT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by SGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)

    ZGEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by ZGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface gemqr

GEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)

  • public pure subroutine cgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    CGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    DGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DGEQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    SGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SGEQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)

    ZGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZGEQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gemqrt

GEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    CGEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    DGEMQRT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by DGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    SGEMQRT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by SGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)

    ZGEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by ZGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface geqlf

GEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

  • public pure subroutine cgeqlf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeqlf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeqlf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeqlf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeqlf(m, n, a, lda, tau, work, lwork, info)

    CGEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeqlf(m, n, a, lda, tau, work, lwork, info)

    DGEQLF computes a QL factorization of a real M-by-N matrix A: A = Q * L.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeqlf(m, n, a, lda, tau, work, lwork, info)

    SGEQLF computes a QL factorization of a real M-by-N matrix A: A = Q * L.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeqlf(m, n, a, lda, tau, work, lwork, info)

    ZGEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface geqr

GEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

  • public pure subroutine cgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    CGEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    DGEQR computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    SGEQR computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeqr(m, n, a, lda, t, tsize, work, lwork, info)

    ZGEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(*)
    integer(kind=ilp), intent(in) :: tsize
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface geqr2p

GEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

  • public subroutine cgeqr2p(m, n, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgeqr2p(m, n, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgeqr2p(m, n, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgeqr2p(m, n, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgeqr2p(m, n, a, lda, tau, work, info)

    CGEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgeqr2p(m, n, a, lda, tau, work, info)

    DGEQR2P computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgeqr2p(m, n, a, lda, tau, work, info)

    SGEQR2P computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgeqr2p(m, n, a, lda, tau, work, info)

    ZGEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface geqrf

GEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

  • public pure subroutine cgeqrf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeqrf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeqrf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeqrf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeqrf(m, n, a, lda, tau, work, lwork, info)

    CGEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeqrf(m, n, a, lda, tau, work, lwork, info)

    DGEQRF computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeqrf(m, n, a, lda, tau, work, lwork, info)

    SGEQRF computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeqrf(m, n, a, lda, tau, work, lwork, info)

    ZGEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface geqrfp

CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

  • public subroutine cgeqrfp(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgeqrfp(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgeqrfp(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgeqrfp(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgeqrfp(m, n, a, lda, tau, work, lwork, info)

    CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgeqrfp(m, n, a, lda, tau, work, lwork, info)

    DGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgeqrfp(m, n, a, lda, tau, work, lwork, info)

    SGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgeqrfp(m, n, a, lda, tau, work, lwork, info)

    ZGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface geqrt

GEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

  • public pure subroutine cgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    CGEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    DGEQRT computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    SGEQRT computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeqrt(m, n, nb, a, lda, t, ldt, work, info)

    ZGEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface geqrt2

GEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

  • public pure subroutine cgeqrt2(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgeqrt2(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgeqrt2(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgeqrt2(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgeqrt2(m, n, a, lda, t, ldt, info)

    CGEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgeqrt2(m, n, a, lda, t, ldt, info)

    DGEQRT2 computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgeqrt2(m, n, a, lda, t, ldt, info)

    SGEQRT2 computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgeqrt2(m, n, a, lda, t, ldt, info)

    ZGEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info

public interface geqrt3

GEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

  • public pure recursive subroutine cgeqrt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine dgeqrt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine sgeqrt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine zgeqrt3(m, n, a, lda, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_cgeqrt3(m, n, a, lda, t, ldt, info)

    CGEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_dgeqrt3(m, n, a, lda, t, ldt, info)

    DGEQRT3 recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_sgeqrt3(m, n, a, lda, t, ldt, info)

    SGEQRT3 recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_zgeqrt3(m, n, a, lda, t, ldt, info)

    ZGEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info

public interface gerfs

GERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gerqf

GERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

  • public pure subroutine cgerqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgerqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgerqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgerqf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgerqf(m, n, a, lda, tau, work, lwork, info)

    CGERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgerqf(m, n, a, lda, tau, work, lwork, info)

    DGERQF computes an RQ factorization of a real M-by-N matrix A: A = R * Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgerqf(m, n, a, lda, tau, work, lwork, info)

    SGERQF computes an RQ factorization of a real M-by-N matrix A: A = R * Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgerqf(m, n, a, lda, tau, work, lwork, info)

    ZGERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gesdd

GESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine cgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info)

    CGESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info)

    DGESDD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info)

    SGESDD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info)

    ZGESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gesv

GESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    CGESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    DGESV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    SGESV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgesv(n, nrhs, a, lda, ipiv, b, ldb, info)

    ZGESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface gesvd

GESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

  • public subroutine cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)

    CGESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)

    DGESVD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)

    SGESVD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)

    ZGESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobvt
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gesvdq

GESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

  • public subroutine cgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    complex(kind=sp), intent(out) :: cwork(*)
    integer(kind=ilp), intent(inout) :: lcwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(inout) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(inout) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    complex(kind=dp), intent(out) :: cwork(*)
    integer(kind=ilp), intent(inout) :: lcwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)

    CGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    complex(kind=sp), intent(out) :: cwork(*)
    integer(kind=ilp), intent(inout) :: lcwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)

    DGESVDQ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(inout) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)

    SGESVDQ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(inout) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)

    ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobp
    character, intent(in) :: jobr
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: numrank
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    complex(kind=dp), intent(out) :: cwork(*)
    integer(kind=ilp), intent(inout) :: lcwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info

public interface gesvj

GESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

  • public pure subroutine cgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(inout) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(inout) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info)

    CGESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(inout) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info)

    DGESVJ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. DGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info)

    SGESVJ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. SGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info)

    ZGESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: joba
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: cwork(lwork)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(inout) :: rwork(lrwork)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info

public interface getrf

GETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

  • public pure subroutine cgetrf(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgetrf(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgetrf(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgetrf(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgetrf(m, n, a, lda, ipiv, info)

    CGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgetrf(m, n, a, lda, ipiv, info)

    DGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgetrf(m, n, a, lda, ipiv, info)

    SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgetrf(m, n, a, lda, ipiv, info)

    ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface getrf2

GETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

  • public pure recursive subroutine cgetrf2(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine dgetrf2(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine sgetrf2(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine zgetrf2(m, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_cgetrf2(m, n, a, lda, ipiv, info)

    CGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_dgetrf2(m, n, a, lda, ipiv, info)

    DGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_sgetrf2(m, n, a, lda, ipiv, info)

    SGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_zgetrf2(m, n, a, lda, ipiv, info)

    ZGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface getri

GETRI computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

  • public pure subroutine cgetri(n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgetri(n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgetri(n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgetri(n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgetri(n, a, lda, ipiv, work, lwork, info)

    CGETRI computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgetri(n, a, lda, ipiv, work, lwork, info)

    DGETRI computes the inverse of a matrix using the LU factorization computed by DGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgetri(n, a, lda, ipiv, work, lwork, info)

    SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgetri(n, a, lda, ipiv, work, lwork, info)

    ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface getrs

GETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.

  • public pure subroutine cgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    CGETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    DGETRS solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    SGETRS solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info)

    ZGETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by ZGETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface getsls

GETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

  • public subroutine cgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    CGETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    DGETSLS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    SGETSLS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)

    ZGETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface getsqrhrt

GETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.

  • public pure subroutine cgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    CGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    DGETSQRHRT computes a NB2-sized column blocked QR-factorization of a real M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in DGEQRT (Q is in blocked compact WY-representation). See the documentation of DGEQRT for more details on the format.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    SGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in SGEQRT (Q is in blocked compact WY-representation). See the documentation of SGEQRT for more details on the format.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)

    ZGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in ZGEQRT (Q is in blocked compact WY-representation). See the documentation of ZGEQRT for more details on the format.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb1
    integer(kind=ilp), intent(in) :: nb1
    integer(kind=ilp), intent(in) :: nb2
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ggbak

GGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

  • public pure subroutine cggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: lscale(*)
    real(kind=sp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: lscale(*)
    real(kind=dp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: lscale(*)
    real(kind=sp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: lscale(*)
    real(kind=dp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    CGGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: lscale(*)
    real(kind=sp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    DGGBAK forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by DGGBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: lscale(*)
    real(kind=dp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    SGGBAK forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by SGGBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(in) :: lscale(*)
    real(kind=sp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)

    ZGGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by ZGGBAL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(in) :: lscale(*)
    real(kind=dp), intent(in) :: rscale(*)
    integer(kind=ilp), intent(in) :: m
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    integer(kind=ilp), intent(out) :: info

public interface ggbal

GGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

  • public pure subroutine cggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: lscale(*)
    real(kind=sp), intent(out) :: rscale(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: lscale(*)
    real(kind=dp), intent(out) :: rscale(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: lscale(*)
    real(kind=sp), intent(out) :: rscale(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: lscale(*)
    real(kind=dp), intent(out) :: rscale(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    CGGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: lscale(*)
    real(kind=sp), intent(out) :: rscale(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    DGGBAL balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: lscale(*)
    real(kind=dp), intent(out) :: rscale(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    SGGBAL balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=sp), intent(out) :: lscale(*)
    real(kind=sp), intent(out) :: rscale(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)

    ZGGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: ilo
    integer(kind=ilp), intent(out) :: ihi
    real(kind=dp), intent(out) :: lscale(*)
    real(kind=dp), intent(out) :: rscale(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface gges

GGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

  • public subroutine cgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_c) :: selctg
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    complex(kind=sp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_d) :: selctg
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    real(kind=dp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_s) :: selctg
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    real(kind=sp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_z) :: selctg
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    complex(kind=dp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)

    CGGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_c) :: selctg
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    complex(kind=sp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info)

    DGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)T, (VSL)T(VSR)T ) Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T.The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver DGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be "standardized" by making the corresponding elements of T have the form: [ a 0 ] [ 0 b ] and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_d) :: selctg
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    real(kind=dp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info)

    SGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)T, (VSL)T(VSR)T ) Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T.The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver SGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be "standardized" by making the corresponding elements of T have the form: [ a 0 ] [ 0 b ] and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_s) :: selctg
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    real(kind=sp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)

    ZGGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver ZGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvsl
    character, intent(in) :: jobvsr
    character, intent(in) :: sort
    procedure(stdlib_selctg_z) :: selctg
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: sdim
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(out) :: vsl(ldvsl,*)
    integer(kind=ilp), intent(in) :: ldvsl
    complex(kind=dp), intent(out) :: vsr(ldvsr,*)
    integer(kind=ilp), intent(in) :: ldvsr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    logical(kind=lk), intent(out) :: bwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ggev

GGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).

  • public subroutine cggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    CGGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info)

    DGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B . where u(j)*H is the conjugate-transpose of u(j).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info)

    SGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B . where u(j)*H is the conjugate-transpose of u(j).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)

    ZGGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobvl
    character, intent(in) :: jobvr
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(out) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(out) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ggglm

GGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

  • public pure subroutine cggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(out) :: x(*)
    complex(kind=sp), intent(out) :: y(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: x(*)
    real(kind=dp), intent(out) :: y(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: x(*)
    real(kind=sp), intent(out) :: y(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(out) :: x(*)
    complex(kind=dp), intent(out) :: y(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    CGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(out) :: x(*)
    complex(kind=sp), intent(out) :: y(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    DGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: x(*)
    real(kind=dp), intent(out) :: y(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    SGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: x(*)
    real(kind=sp), intent(out) :: y(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)

    ZGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(out) :: x(*)
    complex(kind=dp), intent(out) :: y(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gghrd

GGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then GGHRD reduces the original problem to generalized Hessenberg form.

  • public pure subroutine cgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    CGGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then CGGHRD reduces the original problem to generalized Hessenberg form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    DGGHRD reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZT*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1T = (Q1Q) * H * (Z1Z)T Q1 * B * Z1T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then DGGHRD reduces the original problem to generalized Hessenberg form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    SGGHRD reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZT*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1T = (Q1Q) * H * (Z1Z)T Q1 * B * Z1T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then SGGHRD reduces the original problem to generalized Hessenberg form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)

    ZGGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then ZGGHRD reduces the original problem to generalized Hessenberg form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info

public interface gglse

GGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

  • public pure subroutine cgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(out) :: x(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: x(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: x(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(out) :: x(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    CGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(out) :: x(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    DGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: x(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    SGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: x(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)

    ZGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(out) :: x(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ggqrf

GGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.

  • public pure subroutine cggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: taua(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: taub(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: taua(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: taub(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: taua(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: taub(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: taua(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: taub(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    CGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: taua(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: taub(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    DGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: taua(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: taub(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    SGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: taua(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: taub(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)

    ZGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z**H denotes the conjugate transpose of matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: taua(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: taub(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ggrqf

GGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

  • public pure subroutine cggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: taua(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: taub(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: taua(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: taub(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: taua(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: taub(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: taua(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: taub(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    CGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: taua(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: taub(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    DGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: taua(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: taub(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    SGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: taua(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: taub(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)

    ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: taua(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: taub(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gsvj0

GSVJ0 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

  • public pure subroutine cgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    CGSVJ0 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    DGSVJ0 is called from DGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as DGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    SGSVJ0 is called from SGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as SGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    ZGSVJ0 is called from ZGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gsvj1

GSVJ1 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ GSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

  • public pure subroutine cgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    CGSVJ1 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ CGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    DGSVJ1 is called from DGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as DGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ DGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    SGSVJ1 is called from SGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as SGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ SGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: d(n)
    real(kind=sp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: eps
    real(kind=sp), intent(in) :: sfmin
    real(kind=sp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    real(kind=sp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)

    ZGSVJ1 is called from ZGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ ZGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobv
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: n1
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: d(n)
    real(kind=dp), intent(inout) :: sva(n)
    integer(kind=ilp), intent(in) :: mv
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: eps
    real(kind=dp), intent(in) :: sfmin
    real(kind=dp), intent(in) :: tol
    integer(kind=ilp), intent(in) :: nsweep
    complex(kind=dp), intent(out) :: work(lwork)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface gtcon

GTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info)

    CGTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info)

    DGTCON estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by DGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info)

    SGTCON estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by SGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info)

    ZGTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by ZGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface gtrfs

GTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: dlf(*)
    complex(kind=sp), intent(in) :: df(*)
    complex(kind=sp), intent(in) :: duf(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: dlf(*)
    real(kind=dp), intent(in) :: df(*)
    real(kind=dp), intent(in) :: duf(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: dlf(*)
    real(kind=sp), intent(in) :: df(*)
    real(kind=sp), intent(in) :: duf(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: dlf(*)
    complex(kind=dp), intent(in) :: df(*)
    complex(kind=dp), intent(in) :: duf(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: dlf(*)
    complex(kind=sp), intent(in) :: df(*)
    complex(kind=sp), intent(in) :: duf(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: dlf(*)
    real(kind=dp), intent(in) :: df(*)
    real(kind=dp), intent(in) :: duf(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: dlf(*)
    real(kind=sp), intent(in) :: df(*)
    real(kind=sp), intent(in) :: duf(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: dlf(*)
    complex(kind=dp), intent(in) :: df(*)
    complex(kind=dp), intent(in) :: duf(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface gtsv

GTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

  • public pure subroutine cgtsv(n, nrhs, dl, d, du, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: dl(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: du(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgtsv(n, nrhs, dl, d, du, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: dl(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: du(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgtsv(n, nrhs, dl, d, du, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: dl(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: du(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgtsv(n, nrhs, dl, d, du, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: dl(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: du(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgtsv(n, nrhs, dl, d, du, b, ldb, info)

    CGTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: dl(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: du(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgtsv(n, nrhs, dl, d, du, b, ldb, info)

    DGTSV solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: dl(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: du(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgtsv(n, nrhs, dl, d, du, b, ldb, info)

    SGTSV solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: dl(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: du(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgtsv(n, nrhs, dl, d, du, b, ldb, info)

    ZGTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: dl(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: du(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface gttrf

GTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

  • public pure subroutine cgttrf(n, dl, d, du, du2, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: dl(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: du(*)
    complex(kind=sp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgttrf(n, dl, d, du, du2, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: dl(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: du(*)
    real(kind=dp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgttrf(n, dl, d, du, du2, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: dl(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: du(*)
    real(kind=sp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgttrf(n, dl, d, du, du2, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: dl(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: du(*)
    complex(kind=dp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgttrf(n, dl, d, du, du2, ipiv, info)

    CGTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: dl(*)
    complex(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: du(*)
    complex(kind=sp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgttrf(n, dl, d, du, du2, ipiv, info)

    DGTTRF computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: dl(*)
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: du(*)
    real(kind=dp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgttrf(n, dl, d, du, du2, ipiv, info)

    SGTTRF computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: dl(*)
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: du(*)
    real(kind=sp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgttrf(n, dl, d, du, du2, ipiv, info)

    ZGTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: dl(*)
    complex(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: du(*)
    complex(kind=dp), intent(out) :: du2(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface gttrs

GTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

  • public pure subroutine cgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    CGTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    DGTTRS solves one of the systems of equations AX = B or ATX = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    SGTTRS solves one of the systems of equations AX = B or ATX = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)

    ZGTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: du2(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hb2st_kernels

HB2ST_KERNELS is an internal routine used by the CHETRD_HB2ST subroutine.

  • public pure subroutine chb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: v(*)
    complex(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine zhb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: v(*)
    complex(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_chb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    CHB2ST_KERNELS is an internal routine used by the CHETRD_HB2ST subroutine.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: v(*)
    complex(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zhb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    ZHB2ST_KERNELS is an internal routine used by the ZHETRD_HB2ST subroutine.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: v(*)
    complex(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    complex(kind=dp), intent(out) :: work(*)

public interface hbev

HBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

  • public subroutine chbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)

    CHBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)

    ZHBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hbevd

HBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine chbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface hbgst

HBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by CPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.

  • public pure subroutine chbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    complex(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    complex(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)

    CHBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by CPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    complex(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)

    ZHBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by ZPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    complex(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hbgv

HBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

  • public pure subroutine chbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)

    CHBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)

    ZHBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hbgvd

HBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public pure subroutine chbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface hbtrd

HBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

  • public pure subroutine chbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    CHBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    ZHBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hecon

HECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine checon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhecon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_checon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    CHECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhecon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    ZHECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hecon_rook

HECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine checon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhecon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_checon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    CHECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhecon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    ZHECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface heequb

HEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

  • public pure subroutine cheequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zheequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cheequb(uplo, n, a, lda, s, scond, amax, work, info)

    CHEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zheequb(uplo, n, a, lda, s, scond, amax, work, info)

    ZHEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface heev

HEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

  • public subroutine cheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info)

    CHEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info)

    ZHEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface heevd

HEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine cheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface heevr

HEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. HEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, HEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : HEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. HEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

  • public subroutine cheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. ZHEEVR first reduces the matrix A to tridiagonal form T with a call to ZHETRD. Then, whenever possible, ZHEEVR calls ZSTEMR to compute eigenspectrum using Relatively Robust Representations. ZSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see ZSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : ZHEEVR calls ZSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. ZHEEVR calls DSTEBZ and ZSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of ZSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface hegst

HEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPOTRF.

  • public pure subroutine chegst(itype, uplo, n, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhegst(itype, uplo, n, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chegst(itype, uplo, n, a, lda, b, ldb, info)

    CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhegst(itype, uplo, n, a, lda, b, ldb, info)

    ZHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by ZPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hegv

HEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.

  • public subroutine chegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)

    CHEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)

    ZHEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hegvd

HEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine chegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface herfs

HERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CHERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZHERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hesv

HESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine chesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CHESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZHESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hesv_aa

HESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine chesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CHESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZHESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hesv_rk

HESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.

  • public pure subroutine chesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    CHESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    ZHESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine ZHETRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hesv_rook

HESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2).

  • public pure subroutine chesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CHESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZHESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling ZHETRS_ROOK (uses BLAS 2).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface heswapr

HESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.

  • public pure subroutine cheswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine zheswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_cheswapr(uplo, n, a, lda, i1, i2)

    CHESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_zheswapr(uplo, n, a, lda, i1, i2)

    ZHESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2

public interface hetf2_rk

HETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

  • public pure subroutine chetf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetf2_rk(uplo, n, a, lda, e, ipiv, info)

    CHETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetf2_rk(uplo, n, a, lda, e, ipiv, info)

    ZHETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface hetf2_rook

HETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

  • public pure subroutine chetf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetf2_rook(uplo, n, a, lda, ipiv, info)

    CHETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetf2_rook(uplo, n, a, lda, ipiv, info)

    ZHETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface hetrd

HETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

  • public pure subroutine chetrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrd_hb2st

HETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

  • public pure subroutine chetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    CHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    ZHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrd_he2hb

HETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

  • public pure subroutine chetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    CHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    ZHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrf

HETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine chetrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrf(uplo, n, a, lda, ipiv, work, lwork, info)

    CHETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrf(uplo, n, a, lda, ipiv, work, lwork, info)

    ZHETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrf_aa

HETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine chetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    CHETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    ZHETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrf_rk

HETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

  • public pure subroutine chetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    CHETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    ZHETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrf_rook

HETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine chetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    CHETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    ZHETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetri

HETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF.

  • public pure subroutine chetri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetri(uplo, n, a, lda, ipiv, work, info)

    CHETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetri(uplo, n, a, lda, ipiv, work, info)

    ZHETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hetri_rook

HETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK.

  • public pure subroutine chetri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetri_rook(uplo, n, a, lda, ipiv, work, info)

    CHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetri_rook(uplo, n, a, lda, ipiv, work, info)

    ZHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hetrs

HETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF.

  • public pure subroutine chetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    CHETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    ZHETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hetrs2

HETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF and converted by CSYCONV.

  • public pure subroutine chetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    CHETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF and converted by CSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    ZHETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF and converted by ZSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hetrs_3

HETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

  • public pure subroutine chetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    CHETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    ZHETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hetrs_aa

HETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.

  • public pure subroutine chetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CHETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZHETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by ZHETRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface hetrs_rook

HETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.

  • public pure subroutine chetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    CHETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    ZHETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hfrk

Level 3 BLAS like routine for C in RFP Format. HFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

  • public pure subroutine chfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: c(*)
  • public pure subroutine zhfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: c(*)
  • public pure subroutine stdlib_chfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Level 3 BLAS like routine for C in RFP Format. CHFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: c(*)
  • public pure subroutine stdlib_zhfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Level 3 BLAS like routine for C in RFP Format. ZHFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: c(*)

public interface hgeqz

HGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.

  • public subroutine chgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine shgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)

    CHGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)

    DHGEQZ computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_shgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)

    SHGEQZ computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)

    ZHGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hpcon

HPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine chpcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhpcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chpcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    CHPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhpcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    ZHPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by ZHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hpev

HPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

  • public subroutine chpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info)

    CHPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info)

    ZHPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hpevd

HPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine chpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface hpgst

HPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPPTRF.

  • public pure subroutine chpgst(itype, uplo, n, ap, bp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhpgst(itype, uplo, n, ap, bp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chpgst(itype, uplo, n, ap, bp, info)

    CHPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhpgst(itype, uplo, n, ap, bp, info)

    ZHPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by ZPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info

public interface hpgv

HPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

  • public subroutine chpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)

    CHPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)

    ZHPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hpgvd

HPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine chpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CHPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZHPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface hprfs

HPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine chprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CHPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZHPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface hpsv

HPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine chpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    CHPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    ZHPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hptrd

HPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

  • public pure subroutine chptrd(uplo, n, ap, d, e, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhptrd(uplo, n, ap, d, e, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chptrd(uplo, n, ap, d, e, tau, info)

    CHPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhptrd(uplo, n, ap, d, e, tau, info)

    ZHPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info

public interface hptrf

HPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

  • public pure subroutine chptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chptrf(uplo, n, ap, ipiv, info)

    CHPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhptrf(uplo, n, ap, ipiv, info)

    ZHPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface hptri

HPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by CHPTRF.

  • public pure subroutine chptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chptri(uplo, n, ap, ipiv, work, info)

    CHPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by CHPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhptri(uplo, n, ap, ipiv, work, info)

    ZHPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by ZHPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface hptrs

HPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by CHPTRF.

  • public pure subroutine chptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    CHPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by CHPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    ZHPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by ZHPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface hsein

HSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.

  • public subroutine chsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(inout) :: w(*)
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dhsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(inout) :: wr(*)
    real(kind=dp), intent(in) :: wi(*)
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine shsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(inout) :: wr(*)
    real(kind=sp), intent(in) :: wi(*)
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zhsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(inout) :: w(*)
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_chsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)

    CHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(inout) :: w(*)
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dhsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)

    DHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(inout) :: wr(*)
    real(kind=dp), intent(in) :: wi(*)
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_shsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)

    SHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(inout) :: wr(*)
    real(kind=sp), intent(in) :: wi(*)
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zhsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)

    ZHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: eigsrc
    character, intent(in) :: initv
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(inout) :: w(*)
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: ifaill(*)
    integer(kind=ilp), intent(out) :: ifailr(*)
    integer(kind=ilp), intent(out) :: info

public interface hseqr

HSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.

  • public pure subroutine chseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dhseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine shseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zhseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_chseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)

    CHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dhseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)

    DHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_shseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)

    SHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zhseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)

    ZHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface isnan

ISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.

  • public pure function disnan(din)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: din

    Return Value logical(kind=lk)

  • public pure function sisnan(sin)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: sin

    Return Value logical(kind=lk)

  • public pure function stdlib_disnan(din)

    DISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: din

    Return Value logical(kind=lk)

  • public pure function stdlib_sisnan(sin)

    SISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: sin

    Return Value logical(kind=lk)

public interface la_gbamv

LA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

  • public subroutine cla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine dla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine sla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine zla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_cla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    CLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_dla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    DLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_sla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    SLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_zla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)

    ZLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface la_gbrcond

LA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

  • public function dla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function sla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork)

    DLA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork)

    SLA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

public interface la_gbrcond_c

LA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

  • public function cla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function zla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork)

    CLA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork)

    ZLA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

public interface la_gbrpvgrw

LA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

  • public pure function cla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=sp)

  • public pure function dla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=dp)

  • public pure function sla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=sp)

  • public pure function zla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=dp)

  • public pure function stdlib_cla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    CLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=sp)

  • public pure function stdlib_dla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    DLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=dp)

  • public pure function stdlib_sla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    SLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=sp)

  • public pure function stdlib_zla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb)

    ZLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb

    Return Value real(kind=dp)

public interface la_geamv

LA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

  • public subroutine cla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine dla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine sla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine zla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_cla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    CLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_dla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    DLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_sla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    SLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_zla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

    ZLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface la_gercond

LA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

  • public function dla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function sla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    DLA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    SLA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

public interface la_gercond_c

LA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

  • public function cla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function zla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    CLA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    ZLA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

public interface la_gerpvgrw

LA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

  • public pure function cla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=sp)

  • public pure function dla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=dp)

  • public pure function sla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=sp)

  • public pure function zla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=dp)

  • public pure function stdlib_cla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    CLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=sp)

  • public pure function stdlib_dla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    DLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=dp)

  • public pure function stdlib_sla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    SLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=sp)

  • public pure function stdlib_zla_gerpvgrw(n, ncols, a, lda, af, ldaf)

    ZLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf

    Return Value real(kind=dp)

public interface la_heamv

CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

  • public subroutine cla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine zla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_cla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_zla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    ZLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface la_hercond_c

LA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

  • public function cla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function zla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    CLA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    ZLA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

public interface la_herpvgrw

LA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

  • public function cla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    CLA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    ZLA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface la_lin_berr

LA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

  • public pure subroutine cla_lin_berr(n, nz, nrhs, res, ayb, berr)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: res(n,nrhs)
    real(kind=sp), intent(in) :: ayb(n,nrhs)
    real(kind=sp), intent(out) :: berr(nrhs)
  • public pure subroutine dla_lin_berr(n, nz, nrhs, res, ayb, berr)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: res(n,nrhs)
    real(kind=dp), intent(in) :: ayb(n,nrhs)
    real(kind=dp), intent(out) :: berr(nrhs)
  • public pure subroutine sla_lin_berr(n, nz, nrhs, res, ayb, berr)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: res(n,nrhs)
    real(kind=sp), intent(in) :: ayb(n,nrhs)
    real(kind=sp), intent(out) :: berr(nrhs)
  • public pure subroutine zla_lin_berr(n, nz, nrhs, res, ayb, berr)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: res(n,nrhs)
    real(kind=dp), intent(in) :: ayb(n,nrhs)
    real(kind=dp), intent(out) :: berr(nrhs)
  • public pure subroutine stdlib_cla_lin_berr(n, nz, nrhs, res, ayb, berr)

    CLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: res(n,nrhs)
    real(kind=sp), intent(in) :: ayb(n,nrhs)
    real(kind=sp), intent(out) :: berr(nrhs)
  • public pure subroutine stdlib_dla_lin_berr(n, nz, nrhs, res, ayb, berr)

    DLA_LIN_BERR computes component-wise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the component-wise absolute value of the matrix or vector Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: res(n,nrhs)
    real(kind=dp), intent(in) :: ayb(n,nrhs)
    real(kind=dp), intent(out) :: berr(nrhs)
  • public pure subroutine stdlib_sla_lin_berr(n, nz, nrhs, res, ayb, berr)

    SLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: res(n,nrhs)
    real(kind=sp), intent(in) :: ayb(n,nrhs)
    real(kind=sp), intent(out) :: berr(nrhs)
  • public pure subroutine stdlib_zla_lin_berr(n, nz, nrhs, res, ayb, berr)

    ZLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: res(n,nrhs)
    real(kind=dp), intent(in) :: ayb(n,nrhs)
    real(kind=dp), intent(out) :: berr(nrhs)

public interface la_porcond

LA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

  • public function dla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function sla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork)

    DLA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork)

    SLA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

public interface la_porcond_c

LA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector

  • public function cla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function zla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork)

    CLA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork)

    ZLA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

public interface la_porpvgrw

LA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

  • public function cla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function sla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    CLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    DLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    SLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work)

    ZLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: ncols
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface la_syamv

LA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

  • public subroutine cla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine dla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine sla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine zla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_cla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_dla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    DLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_sla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    SLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public subroutine stdlib_zla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    ZLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface la_syrcond

LA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

  • public function dla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function sla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    DLA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=dp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork)

    SLA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: cmode
    real(kind=sp), intent(in) :: c(*)
    integer(kind=ilp), intent(out) :: info
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)

    Return Value real(kind=sp)

public interface la_syrcond_c

LA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

  • public function cla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function zla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    CLA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)

    ZLA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: c(*)
    logical(kind=lk), intent(in) :: capply
    integer(kind=ilp), intent(out) :: info
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)

    Return Value real(kind=dp)

public interface la_syrpvgrw

LA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

  • public function cla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function sla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_cla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    CLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    DLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_sla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    SLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work)

    ZLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: info
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface la_wwaddw

LA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

  • public pure subroutine cla_wwaddw(n, x, y, w)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    complex(kind=sp), intent(inout) :: y(*)
    complex(kind=sp), intent(in) :: w(*)
  • public pure subroutine dla_wwaddw(n, x, y, w)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(in) :: w(*)
  • public pure subroutine sla_wwaddw(n, x, y, w)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(in) :: w(*)
  • public pure subroutine zla_wwaddw(n, x, y, w)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    complex(kind=dp), intent(inout) :: y(*)
    complex(kind=dp), intent(in) :: w(*)
  • public pure subroutine stdlib_cla_wwaddw(n, x, y, w)

    CLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    complex(kind=sp), intent(inout) :: y(*)
    complex(kind=sp), intent(in) :: w(*)
  • public pure subroutine stdlib_dla_wwaddw(n, x, y, w)

    DLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(in) :: w(*)
  • public pure subroutine stdlib_sla_wwaddw(n, x, y, w)

    SLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(in) :: w(*)
  • public pure subroutine stdlib_zla_wwaddw(n, x, y, w)

    ZLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    complex(kind=dp), intent(inout) :: y(*)
    complex(kind=dp), intent(in) :: w(*)

public interface labad

LABAD takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

  • public pure subroutine dlabad(small, large)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(inout) :: small
    real(kind=dp), intent(inout) :: large
  • public pure subroutine slabad(small, large)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(inout) :: small
    real(kind=sp), intent(inout) :: large
  • public pure subroutine stdlib_dlabad(small, large)

    DLABAD takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(inout) :: small
    real(kind=dp), intent(inout) :: large
  • public pure subroutine stdlib_slabad(small, large)

    SLABAD takes as input the values computed by SLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by SLAMCH. This subroutine is needed because SLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(inout) :: small
    real(kind=sp), intent(inout) :: large

public interface labrd

LABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD

  • public pure subroutine clabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tauq(*)
    complex(kind=sp), intent(out) :: taup(*)
    complex(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=sp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine dlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tauq(*)
    real(kind=dp), intent(out) :: taup(*)
    real(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine slabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tauq(*)
    real(kind=sp), intent(out) :: taup(*)
    real(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine zlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tauq(*)
    complex(kind=dp), intent(out) :: taup(*)
    complex(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=dp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine stdlib_clabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    CLABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tauq(*)
    complex(kind=sp), intent(out) :: taup(*)
    complex(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=sp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine stdlib_dlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    DLABRD reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by DGEBRD

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tauq(*)
    real(kind=dp), intent(out) :: taup(*)
    real(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine stdlib_slabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    SLABRD reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by SGEBRD

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tauq(*)
    real(kind=sp), intent(out) :: taup(*)
    real(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy
  • public pure subroutine stdlib_zlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)

    ZLABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by ZGEBRD

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tauq(*)
    complex(kind=dp), intent(out) :: taup(*)
    complex(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    complex(kind=dp), intent(out) :: y(ldy,*)
    integer(kind=ilp), intent(in) :: ldy

public interface lacgv

LACGV conjugates a complex vector of length N.

  • public pure subroutine clacgv(n, x, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine zlacgv(n, x, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_clacgv(n, x, incx)

    CLACGV conjugates a complex vector of length N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_zlacgv(n, x, incx)

    ZLACGV conjugates a complex vector of length N.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx

public interface lacon

LACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

  • public subroutine clacon(n, v, x, est, kase)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(out) :: v(n)
    complex(kind=sp), intent(inout) :: x(n)
    real(kind=sp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine dlacon(n, v, x, isgn, est, kase)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: v(*)
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(out) :: isgn(*)
    real(kind=dp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine slacon(n, v, x, isgn, est, kase)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: v(*)
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(out) :: isgn(*)
    real(kind=sp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine zlacon(n, v, x, est, kase)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(out) :: v(n)
    complex(kind=dp), intent(inout) :: x(n)
    real(kind=dp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine stdlib_clacon(n, v, x, est, kase)

    CLACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(out) :: v(n)
    complex(kind=sp), intent(inout) :: x(n)
    real(kind=sp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine stdlib_dlacon(n, v, x, isgn, est, kase)

    DLACON estimates the 1-norm of a square, real matrix A. Reverse communication is used for evaluating matrix-vector products.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: v(*)
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(out) :: isgn(*)
    real(kind=dp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine stdlib_slacon(n, v, x, isgn, est, kase)

    SLACON estimates the 1-norm of a square, real matrix A. Reverse communication is used for evaluating matrix-vector products.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: v(*)
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(out) :: isgn(*)
    real(kind=sp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase
  • public subroutine stdlib_zlacon(n, v, x, est, kase)

    ZLACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(out) :: v(n)
    complex(kind=dp), intent(inout) :: x(n)
    real(kind=dp), intent(inout) :: est
    integer(kind=ilp), intent(inout) :: kase

public interface lacpy

LACPY copies all or part of a two-dimensional matrix A to another matrix B.

  • public pure subroutine clacpy(uplo, m, n, a, lda, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine dlacpy(uplo, m, n, a, lda, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine slacpy(uplo, m, n, a, lda, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine zlacpy(uplo, m, n, a, lda, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_clacpy(uplo, m, n, a, lda, b, ldb)

    CLACPY copies all or part of a two-dimensional matrix A to another matrix B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_dlacpy(uplo, m, n, a, lda, b, ldb)

    DLACPY copies all or part of a two-dimensional matrix A to another matrix B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_slacpy(uplo, m, n, a, lda, b, ldb)

    SLACPY copies all or part of a two-dimensional matrix A to another matrix B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_zlacpy(uplo, m, n, a, lda, b, ldb)

    ZLACPY copies all or part of a two-dimensional matrix A to another matrix B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb

public interface lacrm

LACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

  • public pure subroutine clacrm(m, n, a, lda, b, ldb, c, ldc, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
  • public pure subroutine zlacrm(m, n, a, lda, b, ldb, c, ldc, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)
  • public pure subroutine stdlib_clacrm(m, n, a, lda, b, ldb, c, ldc, rwork)

    CLACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
  • public pure subroutine stdlib_zlacrm(m, n, a, lda, b, ldb, c, ldc, rwork)

    ZLACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)

public interface lacrt

LACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.

  • public pure subroutine clacrt(n, cx, incx, cy, incy, c, s)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    complex(kind=sp), intent(in) :: c
    complex(kind=sp), intent(in) :: s
  • public pure subroutine zlacrt(n, cx, incx, cy, incy, c, s)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    complex(kind=dp), intent(in) :: c
    complex(kind=dp), intent(in) :: s
  • public pure subroutine stdlib_clacrt(n, cx, incx, cy, incy, c, s)

    CLACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    complex(kind=sp), intent(in) :: c
    complex(kind=sp), intent(in) :: s
  • public pure subroutine stdlib_zlacrt(n, cx, incx, cy, incy, c, s)

    ZLACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    complex(kind=dp), intent(in) :: c
    complex(kind=dp), intent(in) :: s

public interface ladiv1

  • public pure subroutine dladiv1(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(inout) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(out) :: p
    real(kind=dp), intent(out) :: q
  • public pure subroutine sladiv1(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(inout) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(out) :: p
    real(kind=sp), intent(out) :: q
  • public pure subroutine stdlib_dladiv1(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(inout) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(out) :: p
    real(kind=dp), intent(out) :: q
  • public pure subroutine stdlib_sladiv1(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(inout) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(out) :: p
    real(kind=sp), intent(out) :: q

public interface ladiv2

  • public pure function dladiv2(a, b, c, d, r, t)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(in) :: r
    real(kind=dp), intent(in) :: t

    Return Value real(kind=dp)

  • public pure function sladiv2(a, b, c, d, r, t)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(in) :: r
    real(kind=sp), intent(in) :: t

    Return Value real(kind=sp)

  • public pure function stdlib_dladiv2(a, b, c, d, r, t)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(in) :: r
    real(kind=dp), intent(in) :: t

    Return Value real(kind=dp)

  • public pure function stdlib_sladiv2(a, b, c, d, r, t)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(in) :: r
    real(kind=sp), intent(in) :: t

    Return Value real(kind=sp)

public interface ladiv_f

LADIV_F := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.

  • public pure function cladiv(x, y)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: x
    complex(kind=sp), intent(in) :: y

    Return Value complex(kind=sp)

  • public pure function zladiv(x, y)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: x
    complex(kind=dp), intent(in) :: y

    Return Value complex(kind=dp)

  • public pure function stdlib_cladiv(x, y)

    CLADIV := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: x
    complex(kind=sp), intent(in) :: y

    Return Value complex(kind=sp)

  • public pure function stdlib_zladiv(x, y)

    ZLADIV := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: x
    complex(kind=dp), intent(in) :: y

    Return Value complex(kind=dp)

public interface ladiv_s

LADIV_S performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"

  • public pure subroutine dladiv(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(out) :: p
    real(kind=dp), intent(out) :: q
  • public pure subroutine sladiv(a, b, c, d, p, q)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(out) :: p
    real(kind=sp), intent(out) :: q
  • public pure subroutine stdlib_dladiv(a, b, c, d, p, q)

    DLADIV performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a
    real(kind=dp), intent(in) :: b
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: d
    real(kind=dp), intent(out) :: p
    real(kind=dp), intent(out) :: q
  • public pure subroutine stdlib_sladiv(a, b, c, d, p, q)

    SLADIV performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a
    real(kind=sp), intent(in) :: b
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: d
    real(kind=sp), intent(out) :: p
    real(kind=sp), intent(out) :: q

public interface laebz

LAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.

  • public pure subroutine dlaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: nitmax
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mmax
    integer(kind=ilp), intent(in) :: minp
    integer(kind=ilp), intent(in) :: nbmin
    real(kind=dp), intent(in) :: abstol
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: e2(*)
    integer(kind=ilp), intent(inout) :: nval(*)
    real(kind=dp), intent(inout) :: ab(mmax,*)
    real(kind=dp), intent(inout) :: c(*)
    integer(kind=ilp), intent(out) :: mout
    integer(kind=ilp), intent(inout) :: nab(mmax,*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: nitmax
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mmax
    integer(kind=ilp), intent(in) :: minp
    integer(kind=ilp), intent(in) :: nbmin
    real(kind=sp), intent(in) :: abstol
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: e2(*)
    integer(kind=ilp), intent(inout) :: nval(*)
    real(kind=sp), intent(inout) :: ab(mmax,*)
    real(kind=sp), intent(inout) :: c(*)
    integer(kind=ilp), intent(out) :: mout
    integer(kind=ilp), intent(inout) :: nab(mmax,*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info)

    DLAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: nitmax
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mmax
    integer(kind=ilp), intent(in) :: minp
    integer(kind=ilp), intent(in) :: nbmin
    real(kind=dp), intent(in) :: abstol
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: e2(*)
    integer(kind=ilp), intent(inout) :: nval(*)
    real(kind=dp), intent(inout) :: ab(mmax,*)
    real(kind=dp), intent(inout) :: c(*)
    integer(kind=ilp), intent(out) :: mout
    integer(kind=ilp), intent(inout) :: nab(mmax,*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info)

    SLAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: nitmax
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mmax
    integer(kind=ilp), intent(in) :: minp
    integer(kind=ilp), intent(in) :: nbmin
    real(kind=sp), intent(in) :: abstol
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: e2(*)
    integer(kind=ilp), intent(inout) :: nval(*)
    real(kind=sp), intent(inout) :: ab(mmax,*)
    real(kind=sp), intent(inout) :: c(*)
    integer(kind=ilp), intent(out) :: mout
    integer(kind=ilp), intent(inout) :: nab(mmax,*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface laed0

Using the divide and conquer method, LAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.

  • public pure subroutine claed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info)

    Using the divide and conquer method, CLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info)

    DLAED0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info)

    SLAED0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info)

    Using the divide and conquer method, ZLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: qstore(ldqs,*)
    integer(kind=ilp), intent(in) :: ldqs
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface laed1

LAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. DLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

  • public pure subroutine dlaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info)

    DLAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. DLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info)

    SLAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. SLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface laed4

This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

  • public pure subroutine dlaed4(n, i, d, z, delta, rho, dlam, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: z(*)
    real(kind=dp), intent(out) :: delta(*)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dlam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed4(n, i, d, z, delta, rho, dlam, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: z(*)
    real(kind=sp), intent(out) :: delta(*)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dlam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed4(n, i, d, z, delta, rho, dlam, info)

    This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: z(*)
    real(kind=dp), intent(out) :: delta(*)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dlam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed4(n, i, d, z, delta, rho, dlam, info)

    This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: z(*)
    real(kind=sp), intent(out) :: delta(*)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dlam
    integer(kind=ilp), intent(out) :: info

public interface laed5

This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

  • public pure subroutine dlaed5(i, d, z, delta, rho, dlam)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(2)
    real(kind=dp), intent(in) :: z(2)
    real(kind=dp), intent(out) :: delta(2)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dlam
  • public pure subroutine slaed5(i, d, z, delta, rho, dlam)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(2)
    real(kind=sp), intent(in) :: z(2)
    real(kind=sp), intent(out) :: delta(2)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dlam
  • public pure subroutine stdlib_dlaed5(i, d, z, delta, rho, dlam)

    This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(2)
    real(kind=dp), intent(in) :: z(2)
    real(kind=dp), intent(out) :: delta(2)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dlam
  • public pure subroutine stdlib_slaed5(i, d, z, delta, rho, dlam)

    This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(2)
    real(kind=sp), intent(in) :: z(2)
    real(kind=sp), intent(out) :: delta(2)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dlam

public interface laed6

LAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by DLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.

  • public pure subroutine dlaed6(kniter, orgati, rho, d, z, finit, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: kniter
    logical(kind=lk), intent(in) :: orgati
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(in) :: d(3)
    real(kind=dp), intent(in) :: z(3)
    real(kind=dp), intent(in) :: finit
    real(kind=dp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed6(kniter, orgati, rho, d, z, finit, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: kniter
    logical(kind=lk), intent(in) :: orgati
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(in) :: d(3)
    real(kind=sp), intent(in) :: z(3)
    real(kind=sp), intent(in) :: finit
    real(kind=sp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed6(kniter, orgati, rho, d, z, finit, tau, info)

    DLAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by DLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: kniter
    logical(kind=lk), intent(in) :: orgati
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(in) :: d(3)
    real(kind=dp), intent(in) :: z(3)
    real(kind=dp), intent(in) :: finit
    real(kind=dp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed6(kniter, orgati, rho, d, z, finit, tau, info)

    SLAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by SLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: kniter
    logical(kind=lk), intent(in) :: orgati
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(in) :: d(3)
    real(kind=sp), intent(in) :: z(3)
    real(kind=sp), intent(in) :: finit
    real(kind=sp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: info

public interface laed7

LAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

  • public pure subroutine claed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: cutpnt
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=sp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=sp), intent(inout) :: givnum(2,*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=dp), intent(inout) :: givnum(2,*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=sp), intent(inout) :: givnum(2,*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: cutpnt
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=dp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=dp), intent(inout) :: givnum(2,*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info)

    CLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: cutpnt
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=sp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=sp), intent(inout) :: givnum(2,*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info)

    DLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense symmetric matrix that has been reduced to tridiagonal form. DLAED1 handles the case in which all eigenvalues and eigenvectors of a symmetric tridiagonal matrix are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = Q*Tu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED8. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED9). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=dp), intent(inout) :: givnum(2,*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info)

    SLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense symmetric matrix that has been reduced to tridiagonal form. SLAED1 handles the case in which all eigenvalues and eigenvectors of a symmetric tridiagonal matrix are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = Q*Tu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED8. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED9). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=sp), intent(inout) :: givnum(2,*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info)

    ZLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: cutpnt
    integer(kind=ilp), intent(in) :: qsiz
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(out) :: indxq(*)
    real(kind=dp), intent(inout) :: qstore(*)
    integer(kind=ilp), intent(inout) :: qptr(*)
    integer(kind=ilp), intent(inout) :: prmptr(*)
    integer(kind=ilp), intent(inout) :: perm(*)
    integer(kind=ilp), intent(inout) :: givptr(*)
    integer(kind=ilp), intent(inout) :: givcol(2,*)
    real(kind=dp), intent(inout) :: givnum(2,*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface laed8

LAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

  • public pure subroutine claed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(out) :: dlamda(*)
    complex(kind=sp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(inout) :: indxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=sp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(out) :: dlamda(*)
    real(kind=dp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=dp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(out) :: dlamda(*)
    real(kind=sp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=sp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(out) :: dlamda(*)
    complex(kind=dp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(inout) :: indxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=dp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info)

    CLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(out) :: dlamda(*)
    complex(kind=sp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(inout) :: indxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=sp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info)

    DLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(out) :: dlamda(*)
    real(kind=dp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=dp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info)

    SLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: indxq(*)
    real(kind=sp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(out) :: dlamda(*)
    real(kind=sp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=sp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info)

    ZLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(out) :: k
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: qsiz
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: rho
    integer(kind=ilp), intent(in) :: cutpnt
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(out) :: dlamda(*)
    complex(kind=dp), intent(out) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: indxp(*)
    integer(kind=ilp), intent(out) :: indx(*)
    integer(kind=ilp), intent(inout) :: indxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(2,*)
    real(kind=dp), intent(out) :: givnum(2,*)
    integer(kind=ilp), intent(out) :: info

public interface laed9

LAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to DLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.

  • public pure subroutine dlaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: kstart
    integer(kind=ilp), intent(in) :: kstop
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(inout) :: dlamda(*)
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(out) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: kstart
    integer(kind=ilp), intent(in) :: kstop
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(inout) :: dlamda(*)
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(out) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info)

    DLAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to DLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: kstart
    integer(kind=ilp), intent(in) :: kstop
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(inout) :: dlamda(*)
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(out) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info)

    SLAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to SLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: kstart
    integer(kind=ilp), intent(in) :: kstop
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(inout) :: dlamda(*)
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(out) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    integer(kind=ilp), intent(out) :: info

public interface laeda

LAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.

  • public pure subroutine dlaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    integer(kind=ilp), intent(in) :: prmptr(*)
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(2,*)
    real(kind=dp), intent(in) :: givnum(2,*)
    real(kind=dp), intent(in) :: q(*)
    integer(kind=ilp), intent(in) :: qptr(*)
    real(kind=dp), intent(out) :: z(*)
    real(kind=dp), intent(out) :: ztemp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    integer(kind=ilp), intent(in) :: prmptr(*)
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(2,*)
    real(kind=sp), intent(in) :: givnum(2,*)
    real(kind=sp), intent(in) :: q(*)
    integer(kind=ilp), intent(in) :: qptr(*)
    real(kind=sp), intent(out) :: z(*)
    real(kind=sp), intent(out) :: ztemp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info)

    DLAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    integer(kind=ilp), intent(in) :: prmptr(*)
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(2,*)
    real(kind=dp), intent(in) :: givnum(2,*)
    real(kind=dp), intent(in) :: q(*)
    integer(kind=ilp), intent(in) :: qptr(*)
    real(kind=dp), intent(out) :: z(*)
    real(kind=dp), intent(out) :: ztemp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info)

    SLAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: tlvls
    integer(kind=ilp), intent(in) :: curlvl
    integer(kind=ilp), intent(in) :: curpbm
    integer(kind=ilp), intent(in) :: prmptr(*)
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(2,*)
    real(kind=sp), intent(in) :: givnum(2,*)
    real(kind=sp), intent(in) :: q(*)
    integer(kind=ilp), intent(in) :: qptr(*)
    real(kind=sp), intent(out) :: z(*)
    real(kind=sp), intent(out) :: ztemp(*)
    integer(kind=ilp), intent(out) :: info

public interface laein

LAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

  • public pure subroutine claein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(in) :: w
    complex(kind=sp), intent(inout) :: v(*)
    complex(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: rwork(*)
    real(kind=sp), intent(in) :: eps3
    real(kind=sp), intent(in) :: smlnum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(in) :: wr
    real(kind=dp), intent(in) :: wi
    real(kind=dp), intent(inout) :: vr(*)
    real(kind=dp), intent(inout) :: vi(*)
    real(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(in) :: eps3
    real(kind=dp), intent(in) :: smlnum
    real(kind=dp), intent(in) :: bignum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(in) :: wr
    real(kind=sp), intent(in) :: wi
    real(kind=sp), intent(inout) :: vr(*)
    real(kind=sp), intent(inout) :: vi(*)
    real(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(in) :: eps3
    real(kind=sp), intent(in) :: smlnum
    real(kind=sp), intent(in) :: bignum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(in) :: w
    complex(kind=dp), intent(inout) :: v(*)
    complex(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: rwork(*)
    real(kind=dp), intent(in) :: eps3
    real(kind=dp), intent(in) :: smlnum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)

    CLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(in) :: w
    complex(kind=sp), intent(inout) :: v(*)
    complex(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: rwork(*)
    real(kind=sp), intent(in) :: eps3
    real(kind=sp), intent(in) :: smlnum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)

    DLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(in) :: wr
    real(kind=dp), intent(in) :: wi
    real(kind=dp), intent(inout) :: vr(*)
    real(kind=dp), intent(inout) :: vi(*)
    real(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(in) :: eps3
    real(kind=dp), intent(in) :: smlnum
    real(kind=dp), intent(in) :: bignum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)

    SLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(in) :: wr
    real(kind=sp), intent(in) :: wi
    real(kind=sp), intent(inout) :: vr(*)
    real(kind=sp), intent(inout) :: vi(*)
    real(kind=sp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(in) :: eps3
    real(kind=sp), intent(in) :: smlnum
    real(kind=sp), intent(in) :: bignum
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)

    ZLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: rightv
    logical(kind=lk), intent(in) :: noinit
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(in) :: w
    complex(kind=dp), intent(inout) :: v(*)
    complex(kind=dp), intent(out) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: rwork(*)
    real(kind=dp), intent(in) :: eps3
    real(kind=dp), intent(in) :: smlnum
    integer(kind=ilp), intent(out) :: info

public interface laesy

LAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]

  • public pure subroutine claesy(a, b, c, rt1, rt2, evscal, cs1, sn1)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: a
    complex(kind=sp), intent(in) :: b
    complex(kind=sp), intent(in) :: c
    complex(kind=sp), intent(out) :: rt1
    complex(kind=sp), intent(out) :: rt2
    complex(kind=sp), intent(out) :: evscal
    complex(kind=sp), intent(out) :: cs1
    complex(kind=sp), intent(out) :: sn1
  • public pure subroutine zlaesy(a, b, c, rt1, rt2, evscal, cs1, sn1)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: a
    complex(kind=dp), intent(in) :: b
    complex(kind=dp), intent(in) :: c
    complex(kind=dp), intent(out) :: rt1
    complex(kind=dp), intent(out) :: rt2
    complex(kind=dp), intent(out) :: evscal
    complex(kind=dp), intent(out) :: cs1
    complex(kind=dp), intent(out) :: sn1
  • public pure subroutine stdlib_claesy(a, b, c, rt1, rt2, evscal, cs1, sn1)

    CLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: a
    complex(kind=sp), intent(in) :: b
    complex(kind=sp), intent(in) :: c
    complex(kind=sp), intent(out) :: rt1
    complex(kind=sp), intent(out) :: rt2
    complex(kind=sp), intent(out) :: evscal
    complex(kind=sp), intent(out) :: cs1
    complex(kind=sp), intent(out) :: sn1
  • public pure subroutine stdlib_zlaesy(a, b, c, rt1, rt2, evscal, cs1, sn1)

    ZLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: a
    complex(kind=dp), intent(in) :: b
    complex(kind=dp), intent(in) :: c
    complex(kind=dp), intent(out) :: rt1
    complex(kind=dp), intent(out) :: rt2
    complex(kind=dp), intent(out) :: evscal
    complex(kind=dp), intent(out) :: cs1
    complex(kind=dp), intent(out) :: sn1

public interface laexc

LAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

  • public subroutine dlaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine slaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dlaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)

    DLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_slaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)

    SLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lagtf

LAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that LAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration.

  • public pure subroutine dlagtf(n, a, lambda, b, c, tol, d, in, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(*)
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(inout) :: b(*)
    real(kind=dp), intent(inout) :: c(*)
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: in(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slagtf(n, a, lambda, b, c, tol, d, in, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(*)
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(inout) :: b(*)
    real(kind=sp), intent(inout) :: c(*)
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: in(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlagtf(n, a, lambda, b, c, tol, d, in, info)

    DLAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that DLAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(*)
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(inout) :: b(*)
    real(kind=dp), intent(inout) :: c(*)
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: in(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slagtf(n, a, lambda, b, c, tol, d, in, info)

    SLAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that SLAGTF may be used, in conjunction with SLAGTS, to obtain eigenvectors of T by inverse iteration.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(*)
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(inout) :: b(*)
    real(kind=sp), intent(inout) :: c(*)
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: in(*)
    integer(kind=ilp), intent(out) :: info

public interface lagtm

LAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

  • public pure subroutine clagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine dlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine slagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine zlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_clagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    CLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_dlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    DLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_slagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    SLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_zlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)

    ZLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb

public interface lagts

LAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.

  • public pure subroutine dlagts(job, n, a, b, c, d, in, y, tol, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(*)
    real(kind=dp), intent(in) :: b(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: d(*)
    integer(kind=ilp), intent(in) :: in(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(inout) :: tol
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slagts(job, n, a, b, c, d, in, y, tol, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(*)
    real(kind=sp), intent(in) :: b(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: d(*)
    integer(kind=ilp), intent(in) :: in(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(inout) :: tol
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlagts(job, n, a, b, c, d, in, y, tol, info)

    DLAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(*)
    real(kind=dp), intent(in) :: b(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: d(*)
    integer(kind=ilp), intent(in) :: in(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(inout) :: tol
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slagts(job, n, a, b, c, d, in, y, tol, info)

    SLAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine SLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(*)
    real(kind=sp), intent(in) :: b(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: d(*)
    integer(kind=ilp), intent(in) :: in(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(inout) :: tol
    integer(kind=ilp), intent(out) :: info

public interface lahef

LAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. LAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    CLAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    ZLAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. ZLAHEF is an auxiliary routine called by ZHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface lahef_aa

LAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

  • public pure subroutine clahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    CLAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    DLAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: work(*)

public interface lahef_rk

LAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    CLAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    ZLAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLAHEF_RK is an auxiliary routine called by ZHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface lahef_rook

LAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. LAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    CLAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    ZLAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. ZLAHEF_ROOK is an auxiliary routine called by ZHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface lahqr

LAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

  • public pure subroutine clahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info)

    CLAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info)

    DLAHQR is an auxiliary routine called by DHSEQR to update the eigenvalues and Schur decomposition already computed by DHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info)

    SLAHQR is an auxiliary routine called by SHSEQR to update the eigenvalues and Schur decomposition already computed by SHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info)

    ZLAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: info

public interface laic1

LAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then LAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH*w.

  • public pure subroutine claic1(job, j, x, sest, w, gamma, sestpr, s, c)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    complex(kind=sp), intent(in) :: x(j)
    real(kind=sp), intent(in) :: sest
    complex(kind=sp), intent(in) :: w(j)
    complex(kind=sp), intent(in) :: gamma
    real(kind=sp), intent(out) :: sestpr
    complex(kind=sp), intent(out) :: s
    complex(kind=sp), intent(out) :: c
  • public pure subroutine dlaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    real(kind=dp), intent(in) :: x(j)
    real(kind=dp), intent(in) :: sest
    real(kind=dp), intent(in) :: w(j)
    real(kind=dp), intent(in) :: gamma
    real(kind=dp), intent(out) :: sestpr
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: c
  • public pure subroutine slaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    real(kind=sp), intent(in) :: x(j)
    real(kind=sp), intent(in) :: sest
    real(kind=sp), intent(in) :: w(j)
    real(kind=sp), intent(in) :: gamma
    real(kind=sp), intent(out) :: sestpr
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: c
  • public pure subroutine zlaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    complex(kind=dp), intent(in) :: x(j)
    real(kind=dp), intent(in) :: sest
    complex(kind=dp), intent(in) :: w(j)
    complex(kind=dp), intent(in) :: gamma
    real(kind=dp), intent(out) :: sestpr
    complex(kind=dp), intent(out) :: s
    complex(kind=dp), intent(out) :: c
  • public pure subroutine stdlib_claic1(job, j, x, sest, w, gamma, sestpr, s, c)

    CLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH*w.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    complex(kind=sp), intent(in) :: x(j)
    real(kind=sp), intent(in) :: sest
    complex(kind=sp), intent(in) :: w(j)
    complex(kind=sp), intent(in) :: gamma
    real(kind=sp), intent(out) :: sestpr
    complex(kind=sp), intent(out) :: s
    complex(kind=sp), intent(out) :: c
  • public pure subroutine stdlib_dlaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    DLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then DLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wT gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]T and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = xT*w.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    real(kind=dp), intent(in) :: x(j)
    real(kind=dp), intent(in) :: sest
    real(kind=dp), intent(in) :: w(j)
    real(kind=dp), intent(in) :: gamma
    real(kind=dp), intent(out) :: sestpr
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: c
  • public pure subroutine stdlib_slaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    SLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then SLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wT gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]T and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = xT*w.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    real(kind=sp), intent(in) :: x(j)
    real(kind=sp), intent(in) :: sest
    real(kind=sp), intent(in) :: w(j)
    real(kind=sp), intent(in) :: gamma
    real(kind=sp), intent(out) :: sestpr
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: c
  • public pure subroutine stdlib_zlaic1(job, j, x, sest, w, gamma, sestpr, s, c)

    ZLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then ZLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH * w.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: job
    integer(kind=ilp), intent(in) :: j
    complex(kind=dp), intent(in) :: x(j)
    real(kind=dp), intent(in) :: sest
    complex(kind=dp), intent(in) :: w(j)
    complex(kind=dp), intent(in) :: gamma
    real(kind=dp), intent(out) :: sestpr
    complex(kind=dp), intent(out) :: s
    complex(kind=dp), intent(out) :: c

public interface laisnan

This routine is not for general use. It exists solely to avoid over-optimization in DISNAN. LAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.

  • public pure function dlaisnan(din1, din2)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: din1
    real(kind=dp), intent(in) :: din2

    Return Value logical(kind=lk)

  • public pure function slaisnan(sin1, sin2)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: sin1
    real(kind=sp), intent(in) :: sin2

    Return Value logical(kind=lk)

  • public pure function stdlib_dlaisnan(din1, din2)

    This routine is not for general use. It exists solely to avoid over-optimization in DISNAN. DLAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: din1
    real(kind=dp), intent(in) :: din2

    Return Value logical(kind=lk)

  • public pure function stdlib_slaisnan(sin1, sin2)

    This routine is not for general use. It exists solely to avoid over-optimization in SISNAN. SLAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: sin1
    real(kind=sp), intent(in) :: sin2

    Return Value logical(kind=lk)

public interface lals0

LALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

  • public pure subroutine clals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(in) :: poles(ldgnum,*)
    real(kind=sp), intent(in) :: difl(*)
    real(kind=sp), intent(in) :: difr(ldgnum,*)
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: s
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(in) :: poles(ldgnum,*)
    real(kind=dp), intent(in) :: difl(*)
    real(kind=dp), intent(in) :: difr(ldgnum,*)
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: s
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(in) :: poles(ldgnum,*)
    real(kind=sp), intent(in) :: difl(*)
    real(kind=sp), intent(in) :: difr(ldgnum,*)
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: s
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(in) :: poles(ldgnum,*)
    real(kind=dp), intent(in) :: difl(*)
    real(kind=dp), intent(in) :: difr(ldgnum,*)
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: s
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info)

    CLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(in) :: poles(ldgnum,*)
    real(kind=sp), intent(in) :: difl(*)
    real(kind=sp), intent(in) :: difr(ldgnum,*)
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: s
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info)

    DLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(in) :: poles(ldgnum,*)
    real(kind=dp), intent(in) :: difl(*)
    real(kind=dp), intent(in) :: difr(ldgnum,*)
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: s
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info)

    SLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(in) :: poles(ldgnum,*)
    real(kind=sp), intent(in) :: difl(*)
    real(kind=sp), intent(in) :: difr(ldgnum,*)
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: c
    real(kind=sp), intent(in) :: s
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info)

    ZLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    integer(kind=ilp), intent(in) :: perm(*)
    integer(kind=ilp), intent(in) :: givptr
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(in) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(in) :: poles(ldgnum,*)
    real(kind=dp), intent(in) :: difl(*)
    real(kind=dp), intent(in) :: difr(ldgnum,*)
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: c
    real(kind=dp), intent(in) :: s
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lalsa

LALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, LALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, LALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by LALSA.

  • public pure subroutine clalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=sp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=sp), intent(in) :: difl(ldu,*)
    real(kind=sp), intent(in) :: difr(ldu,*)
    real(kind=sp), intent(in) :: z(ldu,*)
    real(kind=sp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=sp), intent(in) :: givnum(ldu,*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=dp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=dp), intent(in) :: difl(ldu,*)
    real(kind=dp), intent(in) :: difr(ldu,*)
    real(kind=dp), intent(in) :: z(ldu,*)
    real(kind=dp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=dp), intent(in) :: givnum(ldu,*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=sp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=sp), intent(in) :: difl(ldu,*)
    real(kind=sp), intent(in) :: difr(ldu,*)
    real(kind=sp), intent(in) :: z(ldu,*)
    real(kind=sp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=sp), intent(in) :: givnum(ldu,*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=dp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=dp), intent(in) :: difl(ldu,*)
    real(kind=dp), intent(in) :: difr(ldu,*)
    real(kind=dp), intent(in) :: z(ldu,*)
    real(kind=dp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=dp), intent(in) :: givnum(ldu,*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)

    CLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=sp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=sp), intent(in) :: difl(ldu,*)
    real(kind=sp), intent(in) :: difr(ldu,*)
    real(kind=sp), intent(in) :: z(ldu,*)
    real(kind=sp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=sp), intent(in) :: givnum(ldu,*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    DLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, DLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by DLALSA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=dp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=dp), intent(in) :: difl(ldu,*)
    real(kind=dp), intent(in) :: difr(ldu,*)
    real(kind=dp), intent(in) :: z(ldu,*)
    real(kind=dp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=dp), intent(in) :: givnum(ldu,*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    SLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, SLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by SLALSA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=sp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=sp), intent(in) :: difl(ldu,*)
    real(kind=sp), intent(in) :: difr(ldu,*)
    real(kind=sp), intent(in) :: z(ldu,*)
    real(kind=sp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=sp), intent(in) :: givnum(ldu,*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)

    ZLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by ZLALSA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: bx(ldbx,*)
    integer(kind=ilp), intent(in) :: ldbx
    real(kind=dp), intent(in) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(in) :: vt(ldu,*)
    integer(kind=ilp), intent(in) :: k(*)
    real(kind=dp), intent(in) :: difl(ldu,*)
    real(kind=dp), intent(in) :: difr(ldu,*)
    real(kind=dp), intent(in) :: z(ldu,*)
    real(kind=dp), intent(in) :: poles(ldu,*)
    integer(kind=ilp), intent(in) :: givptr(*)
    integer(kind=ilp), intent(in) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(in) :: perm(ldgcol,*)
    real(kind=dp), intent(in) :: givnum(ldu,*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lalsd

LALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public pure subroutine clalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)

    CLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info)

    DLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info)

    SLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)

    ZLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: rcond
    integer(kind=ilp), intent(out) :: rank
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lamrg

LAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.

  • public pure subroutine dlamrg(n1, n2, a, dtrd1, dtrd2, index)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=dp), intent(in) :: a(*)
    integer(kind=ilp), intent(in) :: dtrd1
    integer(kind=ilp), intent(in) :: dtrd2
    integer(kind=ilp), intent(out) :: index(*)
  • public pure subroutine slamrg(n1, n2, a, strd1, strd2, index)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=sp), intent(in) :: a(*)
    integer(kind=ilp), intent(in) :: strd1
    integer(kind=ilp), intent(in) :: strd2
    integer(kind=ilp), intent(out) :: index(*)
  • public pure subroutine stdlib_dlamrg(n1, n2, a, dtrd1, dtrd2, index)

    DLAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=dp), intent(in) :: a(*)
    integer(kind=ilp), intent(in) :: dtrd1
    integer(kind=ilp), intent(in) :: dtrd2
    integer(kind=ilp), intent(out) :: index(*)
  • public pure subroutine stdlib_slamrg(n1, n2, a, strd1, strd2, index)

    SLAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n1
    integer(kind=ilp), intent(in) :: n2
    real(kind=sp), intent(in) :: a(*)
    integer(kind=ilp), intent(in) :: strd1
    integer(kind=ilp), intent(in) :: strd2
    integer(kind=ilp), intent(out) :: index(*)

public interface lamswlq

LAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)

  • public pure subroutine clamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    CLAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    DLAMSWLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (DLASWLQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    SLAMSWLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (SLASWLQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    ZLAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (ZLASWLQ)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface lamtsqr

LAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)

  • public pure subroutine clamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    CLAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    DLAMTSQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DLATSQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    SLAMTSQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SLATSQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)

    ZLAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZLATSQR)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface laneg

LANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from DLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)

  • public pure function dlaneg(n, d, lld, sigma, pivmin, r)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: r

    Return Value integer(kind=ilp)

  • public pure function slaneg(n, d, lld, sigma, pivmin, r)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: r

    Return Value integer(kind=ilp)

  • public pure function stdlib_dlaneg(n, d, lld, sigma, pivmin, r)

    DLANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from DLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: r

    Return Value integer(kind=ilp)

  • public pure function stdlib_slaneg(n, d, lld, sigma, pivmin, r)

    SLANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from SLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: r

    Return Value integer(kind=ilp)

public interface langb

LANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

  • public function clangb(norm, n, kl, ku, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlangb(norm, n, kl, ku, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slangb(norm, n, kl, ku, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlangb(norm, n, kl, ku, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clangb(norm, n, kl, ku, ab, ldab, work)

    CLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlangb(norm, n, kl, ku, ab, ldab, work)

    DLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slangb(norm, n, kl, ku, ab, ldab, work)

    SLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlangb(norm, n, kl, ku, ab, ldab, work)

    ZLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lange

LANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.

  • public function clange(norm, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlange(norm, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slange(norm, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlange(norm, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clange(norm, m, n, a, lda, work)

    CLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlange(norm, m, n, a, lda, work)

    DLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slange(norm, m, n, a, lda, work)

    SLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlange(norm, m, n, a, lda, work)

    ZLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface langt

LANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.

  • public pure function clangt(norm, n, dl, d, du)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)

    Return Value real(kind=sp)

  • public pure function dlangt(norm, n, dl, d, du)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)

    Return Value real(kind=dp)

  • public pure function slangt(norm, n, dl, d, du)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)

    Return Value real(kind=sp)

  • public pure function zlangt(norm, n, dl, d, du)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)

    Return Value real(kind=dp)

  • public pure function stdlib_clangt(norm, n, dl, d, du)

    CLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: dl(*)
    complex(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: du(*)

    Return Value real(kind=sp)

  • public pure function stdlib_dlangt(norm, n, dl, d, du)

    DLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: dl(*)
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: du(*)

    Return Value real(kind=dp)

  • public pure function stdlib_slangt(norm, n, dl, d, du)

    SLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: dl(*)
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: du(*)

    Return Value real(kind=sp)

  • public pure function stdlib_zlangt(norm, n, dl, d, du)

    ZLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: dl(*)
    complex(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: du(*)

    Return Value real(kind=dp)

public interface lanhb

LANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.

  • public function clanhb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlanhb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clanhb(norm, uplo, n, k, ab, ldab, work)

    CLANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlanhb(norm, uplo, n, k, ab, ldab, work)

    ZLANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lanhe

LANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.

  • public function clanhe(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlanhe(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clanhe(norm, uplo, n, a, lda, work)

    CLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlanhe(norm, uplo, n, a, lda, work)

    ZLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lanhf

LANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.

  • public function clanhf(norm, transr, uplo, n, a, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(out) :: work(0:*)

    Return Value real(kind=sp)

  • public function zlanhf(norm, transr, uplo, n, a, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(out) :: work(0:*)

    Return Value real(kind=dp)

  • public function stdlib_clanhf(norm, transr, uplo, n, a, work)

    CLANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(out) :: work(0:*)

    Return Value real(kind=sp)

  • public function stdlib_zlanhf(norm, transr, uplo, n, a, work)

    ZLANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(out) :: work(0:*)

    Return Value real(kind=dp)

public interface lanhp

LANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.

  • public function clanhp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlanhp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clanhp(norm, uplo, n, ap, work)

    CLANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlanhp(norm, uplo, n, ap, work)

    ZLANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lanhs

LANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

  • public function clanhs(norm, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlanhs(norm, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slanhs(norm, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlanhs(norm, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clanhs(norm, n, a, lda, work)

    CLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlanhs(norm, n, a, lda, work)

    DLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slanhs(norm, n, a, lda, work)

    SLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlanhs(norm, n, a, lda, work)

    ZLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lanht

LANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.

  • public pure function clanht(norm, n, d, e)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)

    Return Value real(kind=sp)

  • public pure function zlanht(norm, n, d, e)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)

    Return Value real(kind=dp)

  • public pure function stdlib_clanht(norm, n, d, e)

    CLANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)

    Return Value real(kind=sp)

  • public pure function stdlib_zlanht(norm, n, d, e)

    ZLANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)

    Return Value real(kind=dp)

public interface lansb

LANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

  • public function clansb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlansb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slansb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlansb(norm, uplo, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clansb(norm, uplo, n, k, ab, ldab, work)

    CLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlansb(norm, uplo, n, k, ab, ldab, work)

    DLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slansb(norm, uplo, n, k, ab, ldab, work)

    SLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlansb(norm, uplo, n, k, ab, ldab, work)

    ZLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lansf

LANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.

  • public function dlansf(norm, transr, uplo, n, a, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(out) :: work(0:*)

    Return Value real(kind=dp)

  • public function slansf(norm, transr, uplo, n, a, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(out) :: work(0:*)

    Return Value real(kind=sp)

  • public function stdlib_dlansf(norm, transr, uplo, n, a, work)

    DLANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(out) :: work(0:*)

    Return Value real(kind=dp)

  • public function stdlib_slansf(norm, transr, uplo, n, a, work)

    SLANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(out) :: work(0:*)

    Return Value real(kind=sp)

public interface lansp

LANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.

  • public function clansp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlansp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slansp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlansp(norm, uplo, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clansp(norm, uplo, n, ap, work)

    CLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlansp(norm, uplo, n, ap, work)

    DLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slansp(norm, uplo, n, ap, work)

    SLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlansp(norm, uplo, n, ap, work)

    ZLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lanst

LANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.

  • public pure function dlanst(norm, n, d, e)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)

    Return Value real(kind=dp)

  • public pure function slanst(norm, n, d, e)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)

    Return Value real(kind=sp)

  • public pure function stdlib_dlanst(norm, n, d, e)

    DLANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)

    Return Value real(kind=dp)

  • public pure function stdlib_slanst(norm, n, d, e)

    SLANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)

    Return Value real(kind=sp)

public interface lansy

LANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.

  • public function clansy(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlansy(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slansy(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlansy(norm, uplo, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clansy(norm, uplo, n, a, lda, work)

    CLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlansy(norm, uplo, n, a, lda, work)

    DLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slansy(norm, uplo, n, a, lda, work)

    SLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlansy(norm, uplo, n, a, lda, work)

    ZLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lantb

LANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

  • public function clantb(norm, uplo, diag, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlantb(norm, uplo, diag, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slantb(norm, uplo, diag, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlantb(norm, uplo, diag, n, k, ab, ldab, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clantb(norm, uplo, diag, n, k, ab, ldab, work)

    CLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlantb(norm, uplo, diag, n, k, ab, ldab, work)

    DLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slantb(norm, uplo, diag, n, k, ab, ldab, work)

    SLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlantb(norm, uplo, diag, n, k, ab, ldab, work)

    ZLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lantp

LANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

  • public function clantp(norm, uplo, diag, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlantp(norm, uplo, diag, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slantp(norm, uplo, diag, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlantp(norm, uplo, diag, n, ap, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clantp(norm, uplo, diag, n, ap, work)

    CLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlantp(norm, uplo, diag, n, ap, work)

    DLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slantp(norm, uplo, diag, n, ap, work)

    SLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlantp(norm, uplo, diag, n, ap, work)

    ZLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface lantr

LANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

  • public function clantr(norm, uplo, diag, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function dlantr(norm, uplo, diag, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function slantr(norm, uplo, diag, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function zlantr(norm, uplo, diag, m, n, a, lda, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_clantr(norm, uplo, diag, m, n, a, lda, work)

    CLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_dlantr(norm, uplo, diag, m, n, a, lda, work)

    DLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

  • public function stdlib_slantr(norm, uplo, diag, m, n, a, lda, work)

    SLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: work(*)

    Return Value real(kind=sp)

  • public function stdlib_zlantr(norm, uplo, diag, m, n, a, lda, work)

    ZLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: work(*)

    Return Value real(kind=dp)

public interface laorhr_col_getrfnp

LAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine LAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

  • public pure subroutine dlaorhr_col_getrfnp(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaorhr_col_getrfnp(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaorhr_col_getrfnp(m, n, a, lda, d, info)

    DLAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine DLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaorhr_col_getrfnp(m, n, a, lda, d, info)

    SLAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine SLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface laorhr_col_getrfnp2

LAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. LAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, LAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

  • public pure recursive subroutine dlaorhr_col_getrfnp2(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine slaorhr_col_getrfnp2(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_dlaorhr_col_getrfnp2(m, n, a, lda, d, info)

    DLAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. DLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, DLAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_slaorhr_col_getrfnp2(m, n, a, lda, d, info)

    SLAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. SLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine SLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, SLAORHR_COL_GETRFNP2 is self-sufficient and can be used without SLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface lapll

Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

  • public pure subroutine clapll(n, x, incx, y, incy, ssmin)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: ssmin
  • public pure subroutine dlapll(n, x, incx, y, incy, ssmin)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: ssmin
  • public pure subroutine slapll(n, x, incx, y, incy, ssmin)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: ssmin
  • public pure subroutine zlapll(n, x, incx, y, incy, ssmin)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: ssmin
  • public pure subroutine stdlib_clapll(n, x, incx, y, incy, ssmin)

    Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: ssmin
  • public pure subroutine stdlib_dlapll(n, x, incx, y, incy, ssmin)

    Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: ssmin
  • public pure subroutine stdlib_slapll(n, x, incx, y, incy, ssmin)

    Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: ssmin
  • public pure subroutine stdlib_zlapll(n, x, incx, y, incy, ssmin)

    Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: ssmin

public interface lapmr

LAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

  • public pure subroutine clapmr(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine dlapmr(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine slapmr(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine zlapmr(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_clapmr(forwrd, m, n, x, ldx, k)

    CLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_dlapmr(forwrd, m, n, x, ldx, k)

    DLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_slapmr(forwrd, m, n, x, ldx, k)

    SLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_zlapmr(forwrd, m, n, x, ldx, k)

    ZLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)

public interface lapmt

LAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

  • public pure subroutine clapmt(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine dlapmt(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine slapmt(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine zlapmt(forwrd, m, n, x, ldx, k)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_clapmt(forwrd, m, n, x, ldx, k)

    CLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_dlapmt(forwrd, m, n, x, ldx, k)

    DLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_slapmt(forwrd, m, n, x, ldx, k)

    SLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)
  • public pure subroutine stdlib_zlapmt(forwrd, m, n, x, ldx, k)

    ZLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: forwrd
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    integer(kind=ilp), intent(inout) :: k(*)

public interface laqgb

LAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

  • public pure subroutine claqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine dlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine slaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    CLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_dlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    DLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_slaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    SLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)

    ZLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqge

LAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

  • public pure subroutine claqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine dlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine slaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    CLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_dlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    DLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_slaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    SLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: r(*)
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: rowcnd
    real(kind=sp), intent(in) :: colcnd
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)

    ZLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: r(*)
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: rowcnd
    real(kind=dp), intent(in) :: colcnd
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqhb

LAQHB equilibrates an Hermitian band matrix A using the scaling factors in the vector S.

  • public pure subroutine claqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    CLAQHB equilibrates an Hermitian band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    ZLAQHB equilibrates a Hermitian band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqhe

LAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.

  • public pure subroutine claqhe(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqhe(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqhe(uplo, n, a, lda, s, scond, amax, equed)

    CLAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqhe(uplo, n, a, lda, s, scond, amax, equed)

    ZLAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqhp

LAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.

  • public pure subroutine claqhp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqhp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqhp(uplo, n, ap, s, scond, amax, equed)

    CLAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqhp(uplo, n, ap, s, scond, amax, equed)

    ZLAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqps

LAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

  • public pure subroutine claqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    complex(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(inout) :: vn1(*)
    real(kind=sp), intent(inout) :: vn2(*)
    complex(kind=sp), intent(inout) :: auxv(*)
    complex(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine dlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(inout) :: vn1(*)
    real(kind=dp), intent(inout) :: vn2(*)
    real(kind=dp), intent(inout) :: auxv(*)
    real(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine slaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(inout) :: vn1(*)
    real(kind=sp), intent(inout) :: vn2(*)
    real(kind=sp), intent(inout) :: auxv(*)
    real(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine zlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    complex(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(inout) :: vn1(*)
    real(kind=dp), intent(inout) :: vn2(*)
    complex(kind=dp), intent(inout) :: auxv(*)
    complex(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine stdlib_claqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    CLAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    complex(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(inout) :: vn1(*)
    real(kind=sp), intent(inout) :: vn2(*)
    complex(kind=sp), intent(inout) :: auxv(*)
    complex(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine stdlib_dlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    DLAQPS computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(inout) :: vn1(*)
    real(kind=dp), intent(inout) :: vn2(*)
    real(kind=dp), intent(inout) :: auxv(*)
    real(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine stdlib_slaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    SLAQPS computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(inout) :: vn1(*)
    real(kind=sp), intent(inout) :: vn2(*)
    real(kind=sp), intent(inout) :: auxv(*)
    real(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
  • public pure subroutine stdlib_zlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)

    ZLAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: offset
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(inout) :: jpvt(*)
    complex(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(inout) :: vn1(*)
    real(kind=dp), intent(inout) :: vn2(*)
    complex(kind=dp), intent(inout) :: auxv(*)
    complex(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf

public interface laqr0

LAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

  • public pure subroutine claqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine slaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    CLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    DLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_slaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    SLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    ZLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface laqr1

Given a 2-by-2 or 3-by-3 matrix H, LAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.

  • public pure subroutine claqr1(n, h, ldh, s1, s2, v)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(in) :: s1
    complex(kind=sp), intent(in) :: s2
    complex(kind=sp), intent(out) :: v(*)
  • public pure subroutine dlaqr1(n, h, ldh, sr1, si1, sr2, si2, v)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(in) :: sr1
    real(kind=dp), intent(in) :: si1
    real(kind=dp), intent(in) :: sr2
    real(kind=dp), intent(in) :: si2
    real(kind=dp), intent(out) :: v(*)
  • public pure subroutine slaqr1(n, h, ldh, sr1, si1, sr2, si2, v)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(in) :: sr1
    real(kind=sp), intent(in) :: si1
    real(kind=sp), intent(in) :: sr2
    real(kind=sp), intent(in) :: si2
    real(kind=sp), intent(out) :: v(*)
  • public pure subroutine zlaqr1(n, h, ldh, s1, s2, v)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(in) :: s1
    complex(kind=dp), intent(in) :: s2
    complex(kind=dp), intent(out) :: v(*)
  • public pure subroutine stdlib_claqr1(n, h, ldh, s1, s2, v)

    Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(in) :: s1
    complex(kind=sp), intent(in) :: s2
    complex(kind=sp), intent(out) :: v(*)
  • public pure subroutine stdlib_dlaqr1(n, h, ldh, sr1, si1, sr2, si2, v)

    Given a 2-by-2 or 3-by-3 matrix H, DLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - (sr1 + isi1)I)(H - (sr2 + isi2)I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(in) :: sr1
    real(kind=dp), intent(in) :: si1
    real(kind=dp), intent(in) :: sr2
    real(kind=dp), intent(in) :: si2
    real(kind=dp), intent(out) :: v(*)
  • public pure subroutine stdlib_slaqr1(n, h, ldh, sr1, si1, sr2, si2, v)

    Given a 2-by-2 or 3-by-3 matrix H, SLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - (sr1 + isi1)I)(H - (sr2 + isi2)I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(in) :: sr1
    real(kind=sp), intent(in) :: si1
    real(kind=sp), intent(in) :: sr2
    real(kind=sp), intent(in) :: si2
    real(kind=sp), intent(out) :: v(*)
  • public pure subroutine stdlib_zlaqr1(n, h, ldh, s1, s2, v)

    Given a 2-by-2 or 3-by-3 matrix H, ZLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(in) :: s1
    complex(kind=dp), intent(in) :: s2
    complex(kind=dp), intent(out) :: v(*)

public interface laqr4

LAQR4 implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. LAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

  • public pure subroutine claqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine slaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    CLAQR4 implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    DLAQR4 implements one level of recursion for DLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by DLAQR0 and, for large enough deflation window size, it may be called by DLAQR3. This subroutine is identical to DLAQR0 except that it calls DLAQR2 instead of DLAQR3. DLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_slaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)

    SLAQR4 implements one level of recursion for SLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by SLAQR0 and, for large enough deflation window size, it may be called by SLAQR3. This subroutine is identical to SLAQR0 except that it calls SLAQR2 instead of SLAQR3. SLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)

    ZLAQR4 implements one level of recursion for ZLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by ZLAQR0 and, for large enough deflation window size, it may be called by ZLAQR3. This subroutine is identical to ZLAQR0 except that it calls ZLAQR2 instead of ZLAQR3. ZLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface laqr5

LAQR5 called by CLAQR0 performs a single small-bulge multi-shift QR sweep.

  • public pure subroutine claqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    complex(kind=sp), intent(inout) :: s(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    complex(kind=sp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    complex(kind=sp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine dlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    real(kind=dp), intent(inout) :: sr(*)
    real(kind=dp), intent(inout) :: si(*)
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    real(kind=dp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    real(kind=dp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine slaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    real(kind=sp), intent(inout) :: sr(*)
    real(kind=sp), intent(inout) :: si(*)
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    real(kind=sp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    real(kind=sp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine zlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    complex(kind=dp), intent(inout) :: s(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    complex(kind=dp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    complex(kind=dp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine stdlib_claqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    CLAQR5 called by CLAQR0 performs a single small-bulge multi-shift QR sweep.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    complex(kind=sp), intent(inout) :: s(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    complex(kind=sp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    complex(kind=sp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine stdlib_dlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    DLAQR5 , called by DLAQR0, performs a single small-bulge multi-shift QR sweep.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    real(kind=dp), intent(inout) :: sr(*)
    real(kind=dp), intent(inout) :: si(*)
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    real(kind=dp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    real(kind=dp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine stdlib_slaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    SLAQR5 , called by SLAQR0, performs a single small-bulge multi-shift QR sweep.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    real(kind=sp), intent(inout) :: sr(*)
    real(kind=sp), intent(inout) :: si(*)
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    real(kind=sp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    real(kind=sp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh
  • public pure subroutine stdlib_zlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)

    ZLAQR5 , called by ZLAQR0, performs a single small-bulge multi-shift QR sweep.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantt
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: kacc22
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ktop
    integer(kind=ilp), intent(in) :: kbot
    integer(kind=ilp), intent(in) :: nshfts
    complex(kind=dp), intent(inout) :: s(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    integer(kind=ilp), intent(in) :: iloz
    integer(kind=ilp), intent(in) :: ihiz
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    integer(kind=ilp), intent(in) :: nv
    complex(kind=dp), intent(out) :: wv(ldwv,*)
    integer(kind=ilp), intent(in) :: ldwv
    integer(kind=ilp), intent(in) :: nh
    complex(kind=dp), intent(out) :: wh(ldwh,*)
    integer(kind=ilp), intent(in) :: ldwh

public interface laqsb

LAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.

  • public pure subroutine claqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine dlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine slaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    CLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_dlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    DLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_slaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    SLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed)

    ZLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqsp

LAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.

  • public pure subroutine claqsp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine dlaqsp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine slaqsp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqsp(uplo, n, ap, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqsp(uplo, n, ap, s, scond, amax, equed)

    CLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_dlaqsp(uplo, n, ap, s, scond, amax, equed)

    DLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_slaqsp(uplo, n, ap, s, scond, amax, equed)

    SLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqsp(uplo, n, ap, s, scond, amax, equed)

    ZLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqsy

LAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.

  • public pure subroutine claqsy(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine dlaqsy(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine slaqsy(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine zlaqsy(uplo, n, a, lda, s, scond, amax, equed)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_claqsy(uplo, n, a, lda, s, scond, amax, equed)

    CLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_dlaqsy(uplo, n, a, lda, s, scond, amax, equed)

    DLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_slaqsy(uplo, n, a, lda, s, scond, amax, equed)

    SLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(in) :: scond
    real(kind=sp), intent(in) :: amax
    character, intent(out) :: equed
  • public pure subroutine stdlib_zlaqsy(uplo, n, a, lda, s, scond, amax, equed)

    ZLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(in) :: scond
    real(kind=dp), intent(in) :: amax
    character, intent(out) :: equed

public interface laqtr

LAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA.

  • public subroutine dlaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ltran
    logical(kind=lk), intent(in) :: lreal
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(in) :: b(*)
    real(kind=dp), intent(in) :: w
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine slaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ltran
    logical(kind=lk), intent(in) :: lreal
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(in) :: b(*)
    real(kind=sp), intent(in) :: w
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dlaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info)

    DLAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ltran
    logical(kind=lk), intent(in) :: lreal
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(in) :: b(*)
    real(kind=dp), intent(in) :: w
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_slaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info)

    SLAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine STRSNA.

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ltran
    logical(kind=lk), intent(in) :: lreal
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(in) :: b(*)
    real(kind=sp), intent(in) :: w
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface laqz0

LAQZ0 computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"

  • public recursive subroutine claqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: alpha(*)
    complex(kind=sp), intent(inout) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine dlaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: alphar(*)
    real(kind=dp), intent(inout) :: alphai(*)
    real(kind=dp), intent(inout) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine slaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: alphar(*)
    real(kind=sp), intent(inout) :: alphai(*)
    real(kind=sp), intent(inout) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine zlaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: alpha(*)
    complex(kind=dp), intent(inout) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_claqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info)

    CLAQZ0 computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: alpha(*)
    complex(kind=sp), intent(inout) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_dlaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info)

    DLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: alphar(*)
    real(kind=dp), intent(inout) :: alphai(*)
    real(kind=dp), intent(inout) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_slaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info)

    SLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: alphar(*)
    real(kind=sp), intent(inout) :: alphai(*)
    real(kind=sp), intent(inout) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_zlaqz0(wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info)

    ZLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: wants
    character, intent(in) :: wantq
    character, intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: alpha(*)
    complex(kind=dp), intent(inout) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: rec
    integer(kind=ilp), intent(out) :: info

public interface laqz1

LAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position

  • public pure subroutine claqz1(ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: istartm
    integer(kind=ilp), intent(in) :: istopm
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(in) :: nq
    integer(kind=ilp), intent(in) :: qstart
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: zstart
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
  • public pure subroutine dlaqz1(a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: sr1
    real(kind=dp), intent(in) :: sr2
    real(kind=dp), intent(in) :: si
    real(kind=dp), intent(in) :: beta1
    real(kind=dp), intent(in) :: beta2
    real(kind=dp), intent(out) :: v(*)
  • public pure subroutine slaqz1(a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: sr1
    real(kind=sp), intent(in) :: sr2
    real(kind=sp), intent(in) :: si
    real(kind=sp), intent(in) :: beta1
    real(kind=sp), intent(in) :: beta2
    real(kind=sp), intent(out) :: v(*)
  • public pure subroutine zlaqz1(ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: istartm
    integer(kind=ilp), intent(in) :: istopm
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(in) :: nq
    integer(kind=ilp), intent(in) :: qstart
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: zstart
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
  • public pure subroutine stdlib_claqz1(ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz)

    CLAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: istartm
    integer(kind=ilp), intent(in) :: istopm
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(in) :: nq
    integer(kind=ilp), intent(in) :: qstart
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: zstart
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
  • public pure subroutine stdlib_dlaqz1(a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v)

    Given a 3-by-3 matrix pencil (A,B), DLAQZ1: sets v to a scalar multiple of the first column of the product () K = (A - (beta2sr2 - isi)B)B^(-1)(beta1A - (sr2 + isi2)B)B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: sr1
    real(kind=dp), intent(in) :: sr2
    real(kind=dp), intent(in) :: si
    real(kind=dp), intent(in) :: beta1
    real(kind=dp), intent(in) :: beta2
    real(kind=dp), intent(out) :: v(*)
  • public pure subroutine stdlib_slaqz1(a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v)

    Given a 3-by-3 matrix pencil (A,B), SLAQZ1: sets v to a scalar multiple of the first column of the product () K = (A - (beta2sr2 - isi)B)B^(-1)(beta1A - (sr2 + isi2)B)B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: sr1
    real(kind=sp), intent(in) :: sr2
    real(kind=sp), intent(in) :: si
    real(kind=sp), intent(in) :: beta1
    real(kind=sp), intent(in) :: beta2
    real(kind=sp), intent(out) :: v(*)
  • public pure subroutine stdlib_zlaqz1(ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz)

    ZLAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: istartm
    integer(kind=ilp), intent(in) :: istopm
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(in) :: nq
    integer(kind=ilp), intent(in) :: qstart
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: nz
    integer(kind=ilp), intent(in) :: zstart
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz

public interface laqz4

LAQZ4 Executes a single multishift QZ sweep

  • public pure subroutine dlaqz4(ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilschur
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    integer(kind=ilp), intent(in) :: nshifts
    integer(kind=ilp), intent(in) :: nblock_desired
    real(kind=dp), intent(inout) :: sr(*)
    real(kind=dp), intent(inout) :: si(*)
    real(kind=dp), intent(inout) :: ss(*)
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: qc(ldqc,*)
    integer(kind=ilp), intent(in) :: ldqc
    real(kind=dp), intent(inout) :: zc(ldzc,*)
    integer(kind=ilp), intent(in) :: ldzc
    real(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaqz4(ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilschur
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    integer(kind=ilp), intent(in) :: nshifts
    integer(kind=ilp), intent(in) :: nblock_desired
    real(kind=sp), intent(inout) :: sr(*)
    real(kind=sp), intent(inout) :: si(*)
    real(kind=sp), intent(inout) :: ss(*)
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: qc(ldqc,*)
    integer(kind=ilp), intent(in) :: ldqc
    real(kind=sp), intent(inout) :: zc(ldzc,*)
    integer(kind=ilp), intent(in) :: ldzc
    real(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaqz4(ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info)

    DLAQZ4 Executes a single multishift QZ sweep

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilschur
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    integer(kind=ilp), intent(in) :: nshifts
    integer(kind=ilp), intent(in) :: nblock_desired
    real(kind=dp), intent(inout) :: sr(*)
    real(kind=dp), intent(inout) :: si(*)
    real(kind=dp), intent(inout) :: ss(*)
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: qc(ldqc,*)
    integer(kind=ilp), intent(in) :: ldqc
    real(kind=dp), intent(inout) :: zc(ldzc,*)
    integer(kind=ilp), intent(in) :: ldzc
    real(kind=dp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaqz4(ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info)

    SLAQZ4 Executes a single multishift QZ sweep

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: ilschur
    logical(kind=lk), intent(in) :: ilq
    logical(kind=lk), intent(in) :: ilz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    integer(kind=ilp), intent(in) :: nshifts
    integer(kind=ilp), intent(in) :: nblock_desired
    real(kind=sp), intent(inout) :: sr(*)
    real(kind=sp), intent(inout) :: si(*)
    real(kind=sp), intent(inout) :: ss(*)
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: qc(ldqc,*)
    integer(kind=ilp), intent(in) :: ldqc
    real(kind=sp), intent(inout) :: zc(ldzc,*)
    integer(kind=ilp), intent(in) :: ldzc
    real(kind=sp), intent(inout) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface lar1v

LAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

  • public pure subroutine clar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: gaptol
    complex(kind=sp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=sp), intent(out) :: ztz
    real(kind=sp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: nrminv
    real(kind=sp), intent(out) :: resid
    real(kind=sp), intent(out) :: rqcorr
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: gaptol
    real(kind=dp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=dp), intent(out) :: ztz
    real(kind=dp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: nrminv
    real(kind=dp), intent(out) :: resid
    real(kind=dp), intent(out) :: rqcorr
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: gaptol
    real(kind=sp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=sp), intent(out) :: ztz
    real(kind=sp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: nrminv
    real(kind=sp), intent(out) :: resid
    real(kind=sp), intent(out) :: rqcorr
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: gaptol
    complex(kind=dp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=dp), intent(out) :: ztz
    real(kind=dp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: nrminv
    real(kind=dp), intent(out) :: resid
    real(kind=dp), intent(out) :: rqcorr
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    CLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: gaptol
    complex(kind=sp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=sp), intent(out) :: ztz
    real(kind=sp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: nrminv
    real(kind=sp), intent(out) :: resid
    real(kind=sp), intent(out) :: rqcorr
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    DLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: gaptol
    real(kind=dp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=dp), intent(out) :: ztz
    real(kind=dp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: nrminv
    real(kind=dp), intent(out) :: resid
    real(kind=dp), intent(out) :: rqcorr
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    SLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=sp), intent(in) :: lambda
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    real(kind=sp), intent(in) :: lld(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: gaptol
    real(kind=sp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=sp), intent(out) :: ztz
    real(kind=sp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: nrminv
    real(kind=sp), intent(out) :: resid
    real(kind=sp), intent(out) :: rqcorr
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)

    ZLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: b1
    integer(kind=ilp), intent(in) :: bn
    real(kind=dp), intent(in) :: lambda
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    real(kind=dp), intent(in) :: lld(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: gaptol
    complex(kind=dp), intent(inout) :: z(*)
    logical(kind=lk), intent(in) :: wantnc
    integer(kind=ilp), intent(out) :: negcnt
    real(kind=dp), intent(out) :: ztz
    real(kind=dp), intent(out) :: mingma
    integer(kind=ilp), intent(inout) :: r
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: nrminv
    real(kind=dp), intent(out) :: resid
    real(kind=dp), intent(out) :: rqcorr
    real(kind=dp), intent(out) :: work(*)

public interface lar2v

LAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )

  • public pure subroutine clar2v(n, x, y, z, incx, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    complex(kind=sp), intent(inout) :: y(*)
    complex(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: c(*)
    complex(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine dlar2v(n, x, y, z, incx, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine slar2v(n, x, y, z, incx, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine zlar2v(n, x, y, z, incx, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    complex(kind=dp), intent(inout) :: y(*)
    complex(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: c(*)
    complex(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_clar2v(n, x, y, z, incx, c, s, incc)

    CLAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    complex(kind=sp), intent(inout) :: y(*)
    complex(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: c(*)
    complex(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_dlar2v(n, x, y, z, incx, c, s, incc)

    DLAR2V applies a vector of real plane rotations from both sides to a sequence of 2-by-2 real symmetric matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( c(i) s(i) ) ( x(i) z(i) ) ( c(i) -s(i) ) ( z(i) y(i) ) ( -s(i) c(i) ) ( z(i) y(i) ) ( s(i) c(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(inout) :: y(*)
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_slar2v(n, x, y, z, incx, c, s, incc)

    SLAR2V applies a vector of real plane rotations from both sides to a sequence of 2-by-2 real symmetric matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( c(i) s(i) ) ( x(i) z(i) ) ( c(i) -s(i) ) ( z(i) y(i) ) ( -s(i) c(i) ) ( z(i) y(i) ) ( s(i) c(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(inout) :: y(*)
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_zlar2v(n, x, y, z, incx, c, s, incc)

    ZLAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    complex(kind=dp), intent(inout) :: y(*)
    complex(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(in) :: c(*)
    complex(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc

public interface larcm

LARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

  • public pure subroutine clarcm(m, n, a, lda, b, ldb, c, ldc, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
  • public pure subroutine zlarcm(m, n, a, lda, b, ldb, c, ldc, rwork)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)
  • public pure subroutine stdlib_clarcm(m, n, a, lda, b, ldb, c, ldc, rwork)

    CLARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: rwork(*)
  • public pure subroutine stdlib_zlarcm(m, n, a, lda, b, ldb, c, ldc, rwork)

    ZLARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: rwork(*)

public interface larf

LARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau.

  • public pure subroutine clarf(side, m, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlarf(side, m, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slarf(side, m, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlarf(side, m, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clarf(side, m, n, v, incv, tau, c, ldc, work)

    CLARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlarf(side, m, n, v, incv, tau, c, ldc, work)

    DLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slarf(side, m, n, v, incv, tau, c, ldc, work)

    SLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlarf(side, m, n, v, incv, tau, c, ldc, work)

    ZLARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH, supply conjg(tau) instead tau.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)

public interface larfb

LARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.

  • public pure subroutine clarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine dlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine slarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine zlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_clarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    CLARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_dlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    DLARFB applies a real block reflector H or its transpose H**T to a real m by n matrix C, from either the left or the right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_slarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    SLARFB applies a real block reflector H or its transpose H**T to a real m by n matrix C, from either the left or the right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_zlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)

    ZLARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork

public interface larfb_gett

LARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

  • public pure subroutine clarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine dlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine slarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine zlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_clarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    CLARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_dlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    DLARFB_GETT applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_slarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    SLARFB_GETT applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_zlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)

    ZLARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: ident
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork

public interface larfg

LARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .

  • public pure subroutine clarfg(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: alpha
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(out) :: tau
  • public pure subroutine dlarfg(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(out) :: tau
  • public pure subroutine slarfg(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(out) :: tau
  • public pure subroutine zlarfg(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: alpha
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(out) :: tau
  • public pure subroutine stdlib_clarfg(n, alpha, x, incx, tau)

    CLARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: alpha
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(out) :: tau
  • public pure subroutine stdlib_dlarfg(n, alpha, x, incx, tau)

    DLARFG generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= tau <= 2.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(out) :: tau
  • public pure subroutine stdlib_slarfg(n, alpha, x, incx, tau)

    SLARFG generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= tau <= 2.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(out) :: tau
  • public pure subroutine stdlib_zlarfg(n, alpha, x, incx, tau)

    ZLARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: alpha
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(out) :: tau

public interface larfgp

LARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.

  • public subroutine clarfgp(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: alpha
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(out) :: tau
  • public subroutine dlarfgp(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(out) :: tau
  • public subroutine slarfgp(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(out) :: tau
  • public subroutine zlarfgp(n, alpha, x, incx, tau)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: alpha
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(out) :: tau
  • public subroutine stdlib_clarfgp(n, alpha, x, incx, tau)

    CLARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: alpha
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(out) :: tau
  • public subroutine stdlib_dlarfgp(n, alpha, x, incx, tau)

    DLARFGP generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is non-negative, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(out) :: tau
  • public subroutine stdlib_slarfgp(n, alpha, x, incx, tau)

    SLARFGP generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is non-negative, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(out) :: tau
  • public subroutine stdlib_zlarfgp(n, alpha, x, incx, tau)

    ZLARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: alpha
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(out) :: tau

public interface larft

LARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V

  • public pure subroutine clarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine dlarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine slarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine zlarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_clarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    CLARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_dlarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    DLARFT forms the triangular factor T of a real block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_slarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    SLARFT forms the triangular factor T of a real block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_zlarft(direct, storev, n, k, v, ldv, tau, t, ldt)

    ZLARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt

public interface larfy

LARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

  • public pure subroutine clarfy(uplo, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlarfy(uplo, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slarfy(uplo, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlarfy(uplo, n, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clarfy(uplo, n, v, incv, tau, c, ldc, work)

    CLARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlarfy(uplo, n, v, incv, tau, c, ldc, work)

    DLARFY applies an elementary reflector, or Householder matrix, H, to an n x n symmetric matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slarfy(uplo, n, v, incv, tau, c, ldc, work)

    SLARFY applies an elementary reflector, or Householder matrix, H, to an n x n symmetric matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlarfy(uplo, n, v, incv, tau, c, ldc, work)

    ZLARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)

public interface largv

LARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.

  • public pure subroutine clargv(n, x, incx, y, incy, c, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine dlargv(n, x, incx, y, incy, c, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine slargv(n, x, incx, y, incy, c, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine zlargv(n, x, incx, y, incy, c, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_clargv(n, x, incx, y, incy, c, incc)

    CLARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_dlargv(n, x, incx, y, incy, c, incc)

    DLARGV generates a vector of real plane rotations, determined by elements of the real vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( a(i) ) ( -s(i) c(i) ) ( y(i) ) = ( 0 )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_slargv(n, x, incx, y, incy, c, incc)

    SLARGV generates a vector of real plane rotations, determined by elements of the real vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( a(i) ) ( -s(i) c(i) ) ( y(i) ) = ( 0 )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_zlargv(n, x, incx, y, incy, c, incc)

    ZLARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in ZLARTG, but differ from the BLAS1 routine ZROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(out) :: c(*)
    integer(kind=ilp), intent(in) :: incc

public interface larnv

LARNV returns a vector of n random complex numbers from a uniform or normal distribution.

  • public pure subroutine clarnv(idist, iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(out) :: x(*)
  • public pure subroutine dlarnv(idist, iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: x(*)
  • public pure subroutine slarnv(idist, iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: x(*)
  • public pure subroutine zlarnv(idist, iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(out) :: x(*)
  • public pure subroutine stdlib_clarnv(idist, iseed, n, x)

    CLARNV returns a vector of n random complex numbers from a uniform or normal distribution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(out) :: x(*)
  • public pure subroutine stdlib_dlarnv(idist, iseed, n, x)

    DLARNV returns a vector of n random real numbers from a uniform or normal distribution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: x(*)
  • public pure subroutine stdlib_slarnv(idist, iseed, n, x)

    SLARNV returns a vector of n random real numbers from a uniform or normal distribution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: x(*)
  • public pure subroutine stdlib_zlarnv(idist, iseed, n, x)

    ZLARNV returns a vector of n random complex numbers from a uniform or normal distribution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: idist
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(out) :: x(*)

public interface larra

Compute the splitting points with threshold SPLTOL. LARRA sets any "small" off-diagonal elements to zero.

  • public pure subroutine dlarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: e2(*)
    real(kind=dp), intent(in) :: spltol
    real(kind=dp), intent(in) :: tnrm
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: e2(*)
    real(kind=sp), intent(in) :: spltol
    real(kind=sp), intent(in) :: tnrm
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info)

    Compute the splitting points with threshold SPLTOL. DLARRA sets any "small" off-diagonal elements to zero.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: e2(*)
    real(kind=dp), intent(in) :: spltol
    real(kind=dp), intent(in) :: tnrm
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info)

    Compute the splitting points with threshold SPLTOL. SLARRA sets any "small" off-diagonal elements to zero.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: e2(*)
    real(kind=sp), intent(in) :: spltol
    real(kind=sp), intent(in) :: tnrm
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: info

public interface larrb

Given the relatively robust representation(RRR) L D L^T, LARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

  • public pure subroutine dlarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: lld(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=dp), intent(in) :: rtol1
    real(kind=dp), intent(in) :: rtol2
    integer(kind=ilp), intent(in) :: offset
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: wgap(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: spdiam
    integer(kind=ilp), intent(in) :: twist
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: lld(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=sp), intent(in) :: rtol1
    real(kind=sp), intent(in) :: rtol2
    integer(kind=ilp), intent(in) :: offset
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: wgap(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: spdiam
    integer(kind=ilp), intent(in) :: twist
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info)

    Given the relatively robust representation(RRR) L D L^T, DLARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: lld(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=dp), intent(in) :: rtol1
    real(kind=dp), intent(in) :: rtol2
    integer(kind=ilp), intent(in) :: offset
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: wgap(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: spdiam
    integer(kind=ilp), intent(in) :: twist
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info)

    Given the relatively robust representation(RRR) L D L^T, SLARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: lld(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=sp), intent(in) :: rtol1
    real(kind=sp), intent(in) :: rtol2
    integer(kind=ilp), intent(in) :: offset
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: wgap(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: spdiam
    integer(kind=ilp), intent(in) :: twist
    integer(kind=ilp), intent(out) :: info

public interface larrc

Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.

  • public pure subroutine dlarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobt
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(out) :: eigcnt
    integer(kind=ilp), intent(out) :: lcnt
    integer(kind=ilp), intent(out) :: rcnt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobt
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(out) :: eigcnt
    integer(kind=ilp), intent(out) :: lcnt
    integer(kind=ilp), intent(out) :: rcnt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info)

    Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobt
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(out) :: eigcnt
    integer(kind=ilp), intent(out) :: lcnt
    integer(kind=ilp), intent(out) :: rcnt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info)

    Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobt
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(out) :: eigcnt
    integer(kind=ilp), intent(out) :: lcnt
    integer(kind=ilp), intent(out) :: rcnt
    integer(kind=ilp), intent(out) :: info

public interface larrd

LARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

  • public pure subroutine dlarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: gers(*)
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: e2(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: nsplit
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: werr(*)
    real(kind=dp), intent(out) :: wl
    real(kind=dp), intent(out) :: wu
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: gers(*)
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: e2(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: nsplit
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: werr(*)
    real(kind=sp), intent(out) :: wl
    real(kind=sp), intent(out) :: wu
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info)

    DLARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: gers(*)
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: e2(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: nsplit
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: werr(*)
    real(kind=dp), intent(out) :: wl
    real(kind=dp), intent(out) :: wu
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info)

    SLARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from SSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: gers(*)
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: e2(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: nsplit
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: werr(*)
    real(kind=sp), intent(out) :: wl
    real(kind=sp), intent(out) :: wu
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface larre

To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, LARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by DSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to conpute all and then discard any unwanted one. As an added benefit, LARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.

  • public pure subroutine dlarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: vl
    real(kind=dp), intent(inout) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: e2(*)
    real(kind=dp), intent(in) :: rtol1
    real(kind=dp), intent(in) :: rtol2
    real(kind=dp), intent(in) :: spltol
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: werr(*)
    real(kind=dp), intent(out) :: wgap(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=dp), intent(out) :: gers(*)
    real(kind=dp), intent(out) :: pivmin
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: vl
    real(kind=sp), intent(inout) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: e2(*)
    real(kind=sp), intent(in) :: rtol1
    real(kind=sp), intent(in) :: rtol2
    real(kind=sp), intent(in) :: spltol
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: werr(*)
    real(kind=sp), intent(out) :: wgap(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=sp), intent(out) :: gers(*)
    real(kind=sp), intent(out) :: pivmin
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info)

    To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, DLARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by DSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to conpute all and then discard any unwanted one. As an added benefit, DLARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: vl
    real(kind=dp), intent(inout) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: e2(*)
    real(kind=dp), intent(in) :: rtol1
    real(kind=dp), intent(in) :: rtol2
    real(kind=dp), intent(in) :: spltol
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: werr(*)
    real(kind=dp), intent(out) :: wgap(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=dp), intent(out) :: gers(*)
    real(kind=dp), intent(out) :: pivmin
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info)

    To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, SLARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by SSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine SLASQ2) to conpute all and then discard any unwanted one. As an added benefit, SLARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: vl
    real(kind=sp), intent(inout) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: e2(*)
    real(kind=sp), intent(in) :: rtol1
    real(kind=sp), intent(in) :: rtol2
    real(kind=sp), intent(in) :: spltol
    integer(kind=ilp), intent(out) :: nsplit
    integer(kind=ilp), intent(out) :: isplit(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: werr(*)
    real(kind=sp), intent(out) :: wgap(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: indexw(*)
    real(kind=sp), intent(out) :: gers(*)
    real(kind=sp), intent(out) :: pivmin
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface larrf

Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), LARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.

  • public pure subroutine dlarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    integer(kind=ilp), intent(in) :: clstrt
    integer(kind=ilp), intent(in) :: clend
    real(kind=dp), intent(in) :: w(*)
    real(kind=dp), intent(inout) :: wgap(*)
    real(kind=dp), intent(in) :: werr(*)
    real(kind=dp), intent(in) :: spdiam
    real(kind=dp), intent(in) :: clgapl
    real(kind=dp), intent(in) :: clgapr
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(out) :: sigma
    real(kind=dp), intent(out) :: dplus(*)
    real(kind=dp), intent(out) :: lplus(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    integer(kind=ilp), intent(in) :: clstrt
    integer(kind=ilp), intent(in) :: clend
    real(kind=sp), intent(in) :: w(*)
    real(kind=sp), intent(inout) :: wgap(*)
    real(kind=sp), intent(in) :: werr(*)
    real(kind=sp), intent(in) :: spdiam
    real(kind=sp), intent(in) :: clgapl
    real(kind=sp), intent(in) :: clgapr
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(out) :: sigma
    real(kind=sp), intent(out) :: dplus(*)
    real(kind=sp), intent(out) :: lplus(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info)

    Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), DLARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: l(*)
    real(kind=dp), intent(in) :: ld(*)
    integer(kind=ilp), intent(in) :: clstrt
    integer(kind=ilp), intent(in) :: clend
    real(kind=dp), intent(in) :: w(*)
    real(kind=dp), intent(inout) :: wgap(*)
    real(kind=dp), intent(in) :: werr(*)
    real(kind=dp), intent(in) :: spdiam
    real(kind=dp), intent(in) :: clgapl
    real(kind=dp), intent(in) :: clgapr
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(out) :: sigma
    real(kind=dp), intent(out) :: dplus(*)
    real(kind=dp), intent(out) :: lplus(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info)

    Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), SLARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: l(*)
    real(kind=sp), intent(in) :: ld(*)
    integer(kind=ilp), intent(in) :: clstrt
    integer(kind=ilp), intent(in) :: clend
    real(kind=sp), intent(in) :: w(*)
    real(kind=sp), intent(inout) :: wgap(*)
    real(kind=sp), intent(in) :: werr(*)
    real(kind=sp), intent(in) :: spdiam
    real(kind=sp), intent(in) :: clgapl
    real(kind=sp), intent(in) :: clgapr
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(out) :: sigma
    real(kind=sp), intent(out) :: dplus(*)
    real(kind=sp), intent(out) :: lplus(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface larrj

Given the initial eigenvalue approximations of T, LARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

  • public pure subroutine dlarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e2(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=dp), intent(in) :: rtol
    integer(kind=ilp), intent(in) :: offset
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: spdiam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e2(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=sp), intent(in) :: rtol
    integer(kind=ilp), intent(in) :: offset
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: spdiam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info)

    Given the initial eigenvalue approximations of T, DLARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e2(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=dp), intent(in) :: rtol
    integer(kind=ilp), intent(in) :: offset
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: spdiam
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info)

    Given the initial eigenvalue approximations of T, SLARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e2(*)
    integer(kind=ilp), intent(in) :: ifirst
    integer(kind=ilp), intent(in) :: ilast
    real(kind=sp), intent(in) :: rtol
    integer(kind=ilp), intent(in) :: offset
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: spdiam
    integer(kind=ilp), intent(out) :: info

public interface larrk

LARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

  • public pure subroutine dlarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: iw
    real(kind=dp), intent(in) :: gl
    real(kind=dp), intent(in) :: gu
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e2(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(out) :: w
    real(kind=dp), intent(out) :: werr
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: iw
    real(kind=sp), intent(in) :: gl
    real(kind=sp), intent(in) :: gu
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e2(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(out) :: w
    real(kind=sp), intent(out) :: werr
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info)

    DLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: iw
    real(kind=dp), intent(in) :: gl
    real(kind=dp), intent(in) :: gu
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e2(*)
    real(kind=dp), intent(in) :: pivmin
    real(kind=dp), intent(in) :: reltol
    real(kind=dp), intent(out) :: w
    real(kind=dp), intent(out) :: werr
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info)

    SLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from SSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: iw
    real(kind=sp), intent(in) :: gl
    real(kind=sp), intent(in) :: gu
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e2(*)
    real(kind=sp), intent(in) :: pivmin
    real(kind=sp), intent(in) :: reltol
    real(kind=sp), intent(out) :: w
    real(kind=sp), intent(out) :: werr
    integer(kind=ilp), intent(out) :: info

public interface larrr

Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.

  • public pure subroutine dlarrr(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrr(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrr(n, d, e, info)

    Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrr(n, d, e, info)

    Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info

public interface larrv

LARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.

  • public pure subroutine clarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: l(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=sp), intent(in) :: minrgp
    real(kind=sp), intent(inout) :: rtol1
    real(kind=sp), intent(inout) :: rtol2
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=sp), intent(in) :: gers(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: l(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=dp), intent(in) :: minrgp
    real(kind=dp), intent(inout) :: rtol1
    real(kind=dp), intent(inout) :: rtol2
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=dp), intent(in) :: gers(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: l(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=sp), intent(in) :: minrgp
    real(kind=sp), intent(inout) :: rtol1
    real(kind=sp), intent(inout) :: rtol2
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=sp), intent(in) :: gers(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: l(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=dp), intent(in) :: minrgp
    real(kind=dp), intent(inout) :: rtol1
    real(kind=dp), intent(inout) :: rtol2
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=dp), intent(in) :: gers(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    CLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: l(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=sp), intent(in) :: minrgp
    real(kind=sp), intent(inout) :: rtol1
    real(kind=sp), intent(inout) :: rtol2
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=sp), intent(in) :: gers(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    DLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by DLARRE.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: l(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=dp), intent(in) :: minrgp
    real(kind=dp), intent(inout) :: rtol1
    real(kind=dp), intent(inout) :: rtol2
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=dp), intent(in) :: gers(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    SLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: l(*)
    real(kind=sp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=sp), intent(in) :: minrgp
    real(kind=sp), intent(inout) :: rtol1
    real(kind=sp), intent(inout) :: rtol2
    real(kind=sp), intent(inout) :: w(*)
    real(kind=sp), intent(inout) :: werr(*)
    real(kind=sp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=sp), intent(in) :: gers(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)

    ZLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by DLARRE.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: l(*)
    real(kind=dp), intent(in) :: pivmin
    integer(kind=ilp), intent(in) :: isplit(*)
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: dol
    integer(kind=ilp), intent(in) :: dou
    real(kind=dp), intent(in) :: minrgp
    real(kind=dp), intent(inout) :: rtol1
    real(kind=dp), intent(inout) :: rtol2
    real(kind=dp), intent(inout) :: w(*)
    real(kind=dp), intent(inout) :: werr(*)
    real(kind=dp), intent(inout) :: wgap(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: indexw(*)
    real(kind=dp), intent(in) :: gers(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lartg

LARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by LARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine CROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>sp stands for single precision from LA_CONSTANTS module.

  • public pure subroutine clartg(f, g, c, s, r)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: f
    complex(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: c
    complex(kind=sp), intent(out) :: s
    complex(kind=sp), intent(out) :: r
  • public pure subroutine dlartg(f, g, c, s, r)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: f
    real(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: r
  • public pure subroutine slartg(f, g, c, s, r)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: f
    real(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: r
  • public pure subroutine zlartg(f, g, c, s, r)

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: f
    complex(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: c
    complex(kind=dp), intent(out) :: s
    complex(kind=dp), intent(out) :: r
  • public pure subroutine stdlib_clartg(f, g, c, s, r)

    CLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by CLARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine CROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>sp stands for single precision from LA_CONSTANTS module.

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=sp), intent(in) :: f
    complex(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: c
    complex(kind=sp), intent(out) :: s
    complex(kind=sp), intent(out) :: r
  • public pure subroutine stdlib_dlartg(f, g, c, s, r)

    DLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -S C ] [ G ] [ 0 ] where C2 + S2 = 1. The mathematical formulas used for C and S are R = sign(F) * sqrt(F2 + G2) C = F / R S = G / R Hence C >= 0. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This version is discontinuous in R at F = 0 but it returns the same C and S as ZLARTG for complex inputs (F,0) and (G,0). This is a more accurate version of the BLAS1 routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0 and (G .ne. 0), then C=0 and S=sign(1,G) without doing any floating point operations (saves work in DBDSQR when there are zeros on the diagonal). If F exceeds G in magnitude, C will be positive. Below, wp=>dp stands for double precision from LA_CONSTANTS module.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: f
    real(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: r
  • public pure subroutine stdlib_slartg(f, g, c, s, r)

    SLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -S C ] [ G ] [ 0 ] where C2 + S2 = 1. The mathematical formulas used for C and S are R = sign(F) * sqrt(F2 + G2) C = F / R S = G / R Hence C >= 0. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This version is discontinuous in R at F = 0 but it returns the same C and S as SLARTG for complex inputs (F,0) and (G,0). This is a more accurate version of the BLAS1 routine SROTG, with the following other differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0 and (G .ne. 0), then C=0 and S=sign(1,G) without doing any floating point operations (saves work in SBDSQR when there are zeros on the diagonal). If F exceeds G in magnitude, C will be positive. Below, wp=>sp stands for single precision from LA_CONSTANTS module.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: f
    real(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: r
  • public pure subroutine stdlib_zlartg(f, g, c, s, r)

    ZLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by DLARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine ZROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>dp stands for double precision from LA_CONSTANTS module.

    Arguments

    TypeIntentOptionalAttributesName
    complex(kind=dp), intent(in) :: f
    complex(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: c
    complex(kind=dp), intent(out) :: s
    complex(kind=dp), intent(out) :: r

public interface lartgp

LARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.

  • public pure subroutine dlartgp(f, g, cs, sn, r)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: f
    real(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: cs
    real(kind=dp), intent(out) :: sn
    real(kind=dp), intent(out) :: r
  • public pure subroutine slartgp(f, g, cs, sn, r)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: f
    real(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: cs
    real(kind=sp), intent(out) :: sn
    real(kind=sp), intent(out) :: r
  • public pure subroutine stdlib_dlartgp(f, g, cs, sn, r)

    DLARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: f
    real(kind=dp), intent(in) :: g
    real(kind=dp), intent(out) :: cs
    real(kind=dp), intent(out) :: sn
    real(kind=dp), intent(out) :: r
  • public pure subroutine stdlib_slartgp(f, g, cs, sn, r)

    SLARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine SROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: f
    real(kind=sp), intent(in) :: g
    real(kind=sp), intent(out) :: cs
    real(kind=sp), intent(out) :: sn
    real(kind=sp), intent(out) :: r

public interface lartgs

LARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.

  • public pure subroutine dlartgs(x, y, sigma, cs, sn)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: x
    real(kind=dp), intent(in) :: y
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(out) :: cs
    real(kind=dp), intent(out) :: sn
  • public pure subroutine slartgs(x, y, sigma, cs, sn)

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: x
    real(kind=sp), intent(in) :: y
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(out) :: cs
    real(kind=sp), intent(out) :: sn
  • public pure subroutine stdlib_dlartgs(x, y, sigma, cs, sn)

    DLARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=dp), intent(in) :: x
    real(kind=dp), intent(in) :: y
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(out) :: cs
    real(kind=dp), intent(out) :: sn
  • public pure subroutine stdlib_slartgs(x, y, sigma, cs, sn)

    SLARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.

    Arguments

    TypeIntentOptionalAttributesName
    real(kind=sp), intent(in) :: x
    real(kind=sp), intent(in) :: y
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(out) :: cs
    real(kind=sp), intent(out) :: sn

public interface lartv

LARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )

  • public pure subroutine clartv(n, x, incx, y, incy, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c(*)
    complex(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine dlartv(n, x, incx, y, incy, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine slartv(n, x, incx, y, incy, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine zlartv(n, x, incx, y, incy, c, s, incc)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c(*)
    complex(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_clartv(n, x, incx, y, incy, c, s, incc)

    CLARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c(*)
    complex(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_dlartv(n, x, incx, y, incy, c, s, incc)

    DLARTV applies a vector of real plane rotations to elements of the real vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -s(i) c(i) ) ( y(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_slartv(n, x, incx, y, incy, c, s, incc)

    SLARTV applies a vector of real plane rotations to elements of the real vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -s(i) c(i) ) ( y(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc
  • public pure subroutine stdlib_zlartv(n, x, incx, y, incy, c, s, incc)

    ZLARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c(*)
    complex(kind=dp), intent(in) :: s(*)
    integer(kind=ilp), intent(in) :: incc

public interface laruv

LARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.

  • public pure subroutine dlaruv(iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: x(n)
  • public pure subroutine slaruv(iseed, n, x)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: x(n)
  • public pure subroutine stdlib_dlaruv(iseed, n, x)

    DLARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(out) :: x(n)
  • public pure subroutine stdlib_slaruv(iseed, n, x)

    SLARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by SLARNV and CLARNV.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(inout) :: iseed(4)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(out) :: x(n)

public interface larz

LARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.

  • public pure subroutine clarz(side, m, n, l, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlarz(side, m, n, l, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slarz(side, m, n, l, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlarz(side, m, n, l, v, incv, tau, c, ldc, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clarz(side, m, n, l, v, incv, tau, c, ldc, work)

    CLARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=sp), intent(in) :: tau
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlarz(side, m, n, l, v, incv, tau, c, ldc, work)

    DLARZ applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by DTZRZF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=dp), intent(in) :: tau
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slarz(side, m, n, l, v, incv, tau, c, ldc, work)

    SLARZ applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by STZRZF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    real(kind=sp), intent(in) :: tau
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlarz(side, m, n, l, v, incv, tau, c, ldc, work)

    ZLARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by ZTZRZF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(in) :: v(*)
    integer(kind=ilp), intent(in) :: incv
    complex(kind=dp), intent(in) :: tau
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)

public interface larzb

LARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

  • public pure subroutine clarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine dlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine slarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine zlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_clarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    CLARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_dlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    DLARZB applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_slarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    SLARZB applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_zlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)

    ZLARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork

public interface larzt

LARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

  • public pure subroutine clarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine dlarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine slarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine zlarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_clarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    CLARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_dlarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    DLARZT forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_slarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    SLARZT forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
  • public pure subroutine stdlib_zlarzt(direct, storev, n, k, v, ldv, tau, t, ldt)

    ZLARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt

public interface lascl

LASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

  • public pure subroutine clascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: cfrom
    real(kind=sp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: cfrom
    real(kind=dp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: cfrom
    real(kind=sp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: cfrom
    real(kind=dp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    CLASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: cfrom
    real(kind=sp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    DLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: cfrom
    real(kind=dp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    SLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=sp), intent(in) :: cfrom
    real(kind=sp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)

    ZLASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: type
    integer(kind=ilp), intent(in) :: kl
    integer(kind=ilp), intent(in) :: ku
    real(kind=dp), intent(in) :: cfrom
    real(kind=dp), intent(in) :: cto
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface lasd0

Using a divide and conquer approach, LASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, DLASDA, computes only the singular values, and optionally, the singular vectors in compact form.

  • public pure subroutine dlasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info)

    Using a divide and conquer approach, DLASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, DLASDA, computes only the singular values, and optionally, the singular vectors in compact form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info)

    Using a divide and conquer approach, SLASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, SLASDA, computes only the singular values, and optionally, the singular vectors in compact form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lasd1

LASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. LASD1 is called from DLASD0. A related subroutine DLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. LASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine DLASD4 (as called by DLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.

  • public pure subroutine dlasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: beta
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: beta
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info)

    DLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. DLASD1 is called from DLASD0. A related subroutine DLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. DLASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine DLASD4 (as called by DLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: beta
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info)

    SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0. A related subroutine SLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. SLASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine SLASD4 (as called by SLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: beta
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lasd4

This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

  • public pure subroutine dlasd4(n, i, d, z, delta, rho, sigma, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: z(*)
    real(kind=dp), intent(out) :: delta(*)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: sigma
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd4(n, i, d, z, delta, rho, sigma, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: z(*)
    real(kind=sp), intent(out) :: delta(*)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: sigma
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd4(n, i, d, z, delta, rho, sigma, work, info)

    This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: z(*)
    real(kind=dp), intent(out) :: delta(*)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: sigma
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd4(n, i, d, z, delta, rho, sigma, work, info)

    This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: z(*)
    real(kind=sp), intent(out) :: delta(*)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: sigma
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lasd5

This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

  • public pure subroutine dlasd5(i, d, z, delta, rho, dsigma, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(2)
    real(kind=dp), intent(in) :: z(2)
    real(kind=dp), intent(out) :: delta(2)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dsigma
    real(kind=dp), intent(out) :: work(2)
  • public pure subroutine slasd5(i, d, z, delta, rho, dsigma, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(2)
    real(kind=sp), intent(in) :: z(2)
    real(kind=sp), intent(out) :: delta(2)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dsigma
    real(kind=sp), intent(out) :: work(2)
  • public pure subroutine stdlib_dlasd5(i, d, z, delta, rho, dsigma, work)

    This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=dp), intent(in) :: d(2)
    real(kind=dp), intent(in) :: z(2)
    real(kind=dp), intent(out) :: delta(2)
    real(kind=dp), intent(in) :: rho
    real(kind=dp), intent(out) :: dsigma
    real(kind=dp), intent(out) :: work(2)
  • public pure subroutine stdlib_slasd5(i, d, z, delta, rho, dsigma, work)

    This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i
    real(kind=sp), intent(in) :: d(2)
    real(kind=sp), intent(in) :: z(2)
    real(kind=sp), intent(out) :: delta(2)
    real(kind=sp), intent(in) :: rho
    real(kind=sp), intent(out) :: dsigma
    real(kind=sp), intent(out) :: work(2)

public interface lasd6

LASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, DLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. LASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in LASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine DLASD4 (as called by DLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. LASD6 is called from DLASDA.

  • public pure subroutine dlasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: beta
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(out) :: poles(ldgnum,*)
    real(kind=dp), intent(out) :: difl(*)
    real(kind=dp), intent(out) :: difr(*)
    real(kind=dp), intent(out) :: z(*)
    integer(kind=ilp), intent(out) :: k
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: beta
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(out) :: poles(ldgnum,*)
    real(kind=sp), intent(out) :: difl(*)
    real(kind=sp), intent(out) :: difr(*)
    real(kind=sp), intent(out) :: z(*)
    integer(kind=ilp), intent(out) :: k
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)

    DLASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, DLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. DLASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in DLASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine DLASD4 (as called by DLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. DLASD6 is called from DLASDA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(inout) :: alpha
    real(kind=dp), intent(inout) :: beta
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(out) :: poles(ldgnum,*)
    real(kind=dp), intent(out) :: difl(*)
    real(kind=dp), intent(out) :: difr(*)
    real(kind=dp), intent(out) :: z(*)
    integer(kind=ilp), intent(out) :: k
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)

    SLASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, SLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. SLASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in SLASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine SLASD4 (as called by SLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. SLASD6 is called from SLASDA.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(inout) :: alpha
    real(kind=sp), intent(inout) :: beta
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(out) :: poles(ldgnum,*)
    real(kind=sp), intent(out) :: difl(*)
    real(kind=sp), intent(out) :: difr(*)
    real(kind=sp), intent(out) :: z(*)
    integer(kind=ilp), intent(out) :: k
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lasd7

LASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. LASD7 is called from DLASD6.

  • public pure subroutine dlasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(out) :: k
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: z(*)
    real(kind=dp), intent(out) :: zw(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(out) :: vfw(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(out) :: vlw(*)
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(out) :: dsigma(*)
    integer(kind=ilp), intent(out) :: idx(*)
    integer(kind=ilp), intent(out) :: idxp(*)
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(out) :: k
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: z(*)
    real(kind=sp), intent(out) :: zw(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(out) :: vfw(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(out) :: vlw(*)
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(out) :: dsigma(*)
    integer(kind=ilp), intent(out) :: idx(*)
    integer(kind=ilp), intent(out) :: idxp(*)
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)

    DLASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. DLASD7 is called from DLASD6.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(out) :: k
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(out) :: z(*)
    real(kind=dp), intent(out) :: zw(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(out) :: vfw(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(out) :: vlw(*)
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(out) :: dsigma(*)
    integer(kind=ilp), intent(out) :: idx(*)
    integer(kind=ilp), intent(out) :: idxp(*)
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=dp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=dp), intent(out) :: c
    real(kind=dp), intent(out) :: s
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)

    SLASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. SLASD7 is called from SLASD6.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: nl
    integer(kind=ilp), intent(in) :: nr
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(out) :: k
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(out) :: z(*)
    real(kind=sp), intent(out) :: zw(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(out) :: vfw(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(out) :: vlw(*)
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(out) :: dsigma(*)
    integer(kind=ilp), intent(out) :: idx(*)
    integer(kind=ilp), intent(out) :: idxp(*)
    integer(kind=ilp), intent(inout) :: idxq(*)
    integer(kind=ilp), intent(out) :: perm(*)
    integer(kind=ilp), intent(out) :: givptr
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    real(kind=sp), intent(out) :: givnum(ldgnum,*)
    integer(kind=ilp), intent(in) :: ldgnum
    real(kind=sp), intent(out) :: c
    real(kind=sp), intent(out) :: s
    integer(kind=ilp), intent(out) :: info

public interface lasd8

LASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to DLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. LASD8 is called from DLASD6.

  • public pure subroutine dlasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(out) :: difl(*)
    real(kind=dp), intent(out) :: difr(lddifr,*)
    integer(kind=ilp), intent(in) :: lddifr
    real(kind=dp), intent(inout) :: dsigma(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(out) :: difl(*)
    real(kind=sp), intent(out) :: difr(lddifr,*)
    integer(kind=ilp), intent(in) :: lddifr
    real(kind=sp), intent(inout) :: dsigma(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)

    DLASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to DLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. DLASD8 is called from DLASD6.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(inout) :: z(*)
    real(kind=dp), intent(inout) :: vf(*)
    real(kind=dp), intent(inout) :: vl(*)
    real(kind=dp), intent(out) :: difl(*)
    real(kind=dp), intent(out) :: difr(lddifr,*)
    integer(kind=ilp), intent(in) :: lddifr
    real(kind=dp), intent(inout) :: dsigma(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)

    SLASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to SLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. SLASD8 is called from SLASD6.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(inout) :: z(*)
    real(kind=sp), intent(inout) :: vf(*)
    real(kind=sp), intent(inout) :: vl(*)
    real(kind=sp), intent(out) :: difl(*)
    real(kind=sp), intent(out) :: difr(lddifr,*)
    integer(kind=ilp), intent(in) :: lddifr
    real(kind=sp), intent(inout) :: dsigma(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lasda

Using a divide and conquer approach, LASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form.

  • public pure subroutine dlasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldu,*)
    integer(kind=ilp), intent(out) :: k(*)
    real(kind=dp), intent(out) :: difl(ldu,*)
    real(kind=dp), intent(out) :: difr(ldu,*)
    real(kind=dp), intent(out) :: z(ldu,*)
    real(kind=dp), intent(out) :: poles(ldu,*)
    integer(kind=ilp), intent(out) :: givptr(*)
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(out) :: perm(ldgcol,*)
    real(kind=dp), intent(out) :: givnum(ldu,*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldu,*)
    integer(kind=ilp), intent(out) :: k(*)
    real(kind=sp), intent(out) :: difl(ldu,*)
    real(kind=sp), intent(out) :: difr(ldu,*)
    real(kind=sp), intent(out) :: z(ldu,*)
    real(kind=sp), intent(out) :: poles(ldu,*)
    integer(kind=ilp), intent(out) :: givptr(*)
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(out) :: perm(ldgcol,*)
    real(kind=sp), intent(out) :: givnum(ldu,*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Using a divide and conquer approach, DLASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(out) :: vt(ldu,*)
    integer(kind=ilp), intent(out) :: k(*)
    real(kind=dp), intent(out) :: difl(ldu,*)
    real(kind=dp), intent(out) :: difr(ldu,*)
    real(kind=dp), intent(out) :: z(ldu,*)
    real(kind=dp), intent(out) :: poles(ldu,*)
    integer(kind=ilp), intent(out) :: givptr(*)
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(out) :: perm(ldgcol,*)
    real(kind=dp), intent(out) :: givnum(ldu,*)
    real(kind=dp), intent(out) :: c(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)

    Using a divide and conquer approach, SLASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, SLASD0, computes the singular values and the singular vectors in explicit form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: icompq
    integer(kind=ilp), intent(in) :: smlsiz
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: sqre
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(out) :: vt(ldu,*)
    integer(kind=ilp), intent(out) :: k(*)
    real(kind=sp), intent(out) :: difl(ldu,*)
    real(kind=sp), intent(out) :: difr(ldu,*)
    real(kind=sp), intent(out) :: z(ldu,*)
    real(kind=sp), intent(out) :: poles(ldu,*)
    integer(kind=ilp), intent(out) :: givptr(*)
    integer(kind=ilp), intent(out) :: givcol(ldgcol,*)
    integer(kind=ilp), intent(in) :: ldgcol
    integer(kind=ilp), intent(out) :: perm(ldgcol,*)
    real(kind=sp), intent(out) :: givnum(ldu,*)
    real(kind=sp), intent(out) :: c(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface lasdq

LASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.

  • public pure subroutine dlasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    DLASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)

    SLASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: sqre
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ncvt
    integer(kind=ilp), intent(in) :: nru
    integer(kind=ilp), intent(in) :: ncc
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: vt(ldvt,*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface laset

LASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

  • public pure subroutine claset(uplo, m, n, alpha, beta, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine dlaset(uplo, m, n, alpha, beta, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine slaset(uplo, m, n, alpha, beta, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine zlaset(uplo, m, n, alpha, beta, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_claset(uplo, m, n, alpha, beta, a, lda)

    CLASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_dlaset(uplo, m, n, alpha, beta, a, lda)

    DLASET initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_slaset(uplo, m, n, alpha, beta, a, lda)

    SLASET initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_zlaset(uplo, m, n, alpha, beta, a, lda)

    ZLASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda

public interface lasq1

LASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.

  • public pure subroutine dlasq1(n, d, e, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasq1(n, d, e, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasq1(n, d, e, work, info)

    DLASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasq1(n, d, e, work, info)

    SLASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface lasq4

LASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.

  • public pure subroutine dlasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    integer(kind=ilp), intent(in) :: n0in
    real(kind=dp), intent(in) :: dmin
    real(kind=dp), intent(in) :: dmin1
    real(kind=dp), intent(in) :: dmin2
    real(kind=dp), intent(in) :: dn
    real(kind=dp), intent(in) :: dn1
    real(kind=dp), intent(in) :: dn2
    real(kind=dp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: ttype
    real(kind=dp), intent(inout) :: g
  • public pure subroutine slasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    integer(kind=ilp), intent(in) :: n0in
    real(kind=sp), intent(in) :: dmin
    real(kind=sp), intent(in) :: dmin1
    real(kind=sp), intent(in) :: dmin2
    real(kind=sp), intent(in) :: dn
    real(kind=sp), intent(in) :: dn1
    real(kind=sp), intent(in) :: dn2
    real(kind=sp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: ttype
    real(kind=sp), intent(inout) :: g
  • public pure subroutine stdlib_dlasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g)

    DLASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    integer(kind=ilp), intent(in) :: n0in
    real(kind=dp), intent(in) :: dmin
    real(kind=dp), intent(in) :: dmin1
    real(kind=dp), intent(in) :: dmin2
    real(kind=dp), intent(in) :: dn
    real(kind=dp), intent(in) :: dn1
    real(kind=dp), intent(in) :: dn2
    real(kind=dp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: ttype
    real(kind=dp), intent(inout) :: g
  • public pure subroutine stdlib_slasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g)

    SLASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(in) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    integer(kind=ilp), intent(in) :: n0in
    real(kind=sp), intent(in) :: dmin
    real(kind=sp), intent(in) :: dmin1
    real(kind=sp), intent(in) :: dmin2
    real(kind=sp), intent(in) :: dn
    real(kind=sp), intent(in) :: dn1
    real(kind=sp), intent(in) :: dn2
    real(kind=sp), intent(out) :: tau
    integer(kind=ilp), intent(out) :: ttype
    real(kind=sp), intent(inout) :: g

public interface lasq5

LASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.

  • public pure subroutine dlasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=dp), intent(inout) :: tau
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(out) :: dmin
    real(kind=dp), intent(out) :: dmin1
    real(kind=dp), intent(out) :: dmin2
    real(kind=dp), intent(out) :: dn
    real(kind=dp), intent(out) :: dnm1
    real(kind=dp), intent(out) :: dnm2
    logical(kind=lk), intent(in) :: ieee
    real(kind=dp), intent(in) :: eps
  • public pure subroutine slasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=sp), intent(inout) :: tau
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(out) :: dmin
    real(kind=sp), intent(out) :: dmin1
    real(kind=sp), intent(out) :: dmin2
    real(kind=sp), intent(out) :: dn
    real(kind=sp), intent(out) :: dnm1
    real(kind=sp), intent(out) :: dnm2
    logical(kind=lk), intent(in) :: ieee
    real(kind=sp), intent(in) :: eps
  • public pure subroutine stdlib_dlasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps)

    DLASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=dp), intent(inout) :: tau
    real(kind=dp), intent(in) :: sigma
    real(kind=dp), intent(out) :: dmin
    real(kind=dp), intent(out) :: dmin1
    real(kind=dp), intent(out) :: dmin2
    real(kind=dp), intent(out) :: dn
    real(kind=dp), intent(out) :: dnm1
    real(kind=dp), intent(out) :: dnm2
    logical(kind=lk), intent(in) :: ieee
    real(kind=dp), intent(in) :: eps
  • public pure subroutine stdlib_slasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps)

    SLASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=sp), intent(inout) :: tau
    real(kind=sp), intent(in) :: sigma
    real(kind=sp), intent(out) :: dmin
    real(kind=sp), intent(out) :: dmin1
    real(kind=sp), intent(out) :: dmin2
    real(kind=sp), intent(out) :: dn
    real(kind=sp), intent(out) :: dnm1
    real(kind=sp), intent(out) :: dnm2
    logical(kind=lk), intent(in) :: ieee
    real(kind=sp), intent(in) :: eps

public interface lasq6

LASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.

  • public pure subroutine dlasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=dp), intent(out) :: dmin
    real(kind=dp), intent(out) :: dmin1
    real(kind=dp), intent(out) :: dmin2
    real(kind=dp), intent(out) :: dn
    real(kind=dp), intent(out) :: dnm1
    real(kind=dp), intent(out) :: dnm2
  • public pure subroutine slasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=sp), intent(out) :: dmin
    real(kind=sp), intent(out) :: dmin1
    real(kind=sp), intent(out) :: dmin2
    real(kind=sp), intent(out) :: dn
    real(kind=sp), intent(out) :: dnm1
    real(kind=sp), intent(out) :: dnm2
  • public pure subroutine stdlib_dlasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)

    DLASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=dp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=dp), intent(out) :: dmin
    real(kind=dp), intent(out) :: dmin1
    real(kind=dp), intent(out) :: dmin2
    real(kind=dp), intent(out) :: dn
    real(kind=dp), intent(out) :: dnm1
    real(kind=dp), intent(out) :: dnm2
  • public pure subroutine stdlib_slasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)

    SLASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: i0
    integer(kind=ilp), intent(in) :: n0
    real(kind=sp), intent(inout) :: z(*)
    integer(kind=ilp), intent(in) :: pp
    real(kind=sp), intent(out) :: dmin
    real(kind=sp), intent(out) :: dmin1
    real(kind=sp), intent(out) :: dmin2
    real(kind=sp), intent(out) :: dn
    real(kind=sp), intent(out) :: dnm1
    real(kind=sp), intent(out) :: dnm2

public interface lasr

LASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

  • public pure subroutine clasr(side, pivot, direct, m, n, c, s, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine dlasr(side, pivot, direct, m, n, c, s, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine slasr(side, pivot, direct, m, n, c, s, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine zlasr(side, pivot, direct, m, n, c, s, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_clasr(side, pivot, direct, m, n, c, s, a, lda)

    CLASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_dlasr(side, pivot, direct, m, n, c, s, a, lda)

    DLASR applies a sequence of plane rotations to a real matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_slasr(side, pivot, direct, m, n, c, s, a, lda)

    SLASR applies a sequence of plane rotations to a real matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: c(*)
    real(kind=sp), intent(in) :: s(*)
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_zlasr(side, pivot, direct, m, n, c, s, a, lda)

    ZLASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: pivot
    character, intent(in) :: direct
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: c(*)
    real(kind=dp), intent(in) :: s(*)
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda

public interface lasrt

Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.

  • public pure subroutine dlasrt(id, n, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: id
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasrt(id, n, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: id
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasrt(id, n, d, info)

    Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: id
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasrt(id, n, d, info)

    Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: id
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface lassq

LASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.

  • public pure subroutine classq(n, x, incx, scl, sumsq)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: scl
    real(kind=sp), intent(inout) :: sumsq
  • public pure subroutine dlassq(n, x, incx, scl, sumsq)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: scl
    real(kind=dp), intent(inout) :: sumsq
  • public pure subroutine slassq(n, x, incx, scl, sumsq)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: scl
    real(kind=sp), intent(inout) :: sumsq
  • public pure subroutine zlassq(n, x, incx, scl, sumsq)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: scl
    real(kind=dp), intent(inout) :: sumsq
  • public pure subroutine stdlib_classq(n, x, incx, scl, sumsq)

    CLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: scl
    real(kind=sp), intent(inout) :: sumsq
  • public pure subroutine stdlib_dlassq(n, x, incx, scl, sumsq)

    DLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: scl
    real(kind=dp), intent(inout) :: sumsq
  • public pure subroutine stdlib_slassq(n, x, incx, scl, sumsq)

    SLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=sp), intent(inout) :: scl
    real(kind=sp), intent(inout) :: sumsq
  • public pure subroutine stdlib_zlassq(n, x, incx, scl, sumsq)

    ZLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    real(kind=dp), intent(inout) :: scl
    real(kind=dp), intent(inout) :: sumsq

public interface laswlq

LASWLQ computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

  • public pure subroutine claswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    CLASWLQ computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    DLASWLQ computes a blocked Tall-Skinny LQ factorization of a real M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    SLASWLQ computes a blocked Tall-Skinny LQ factorization of a real M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    ZLASWLQ computes a blocked Tall-Skinny LQ factorization of a complexx M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface laswp

LASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

  • public pure subroutine claswp(n, a, lda, k1, k2, ipiv, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine dlaswp(n, a, lda, k1, k2, ipiv, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine slaswp(n, a, lda, k1, k2, ipiv, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine zlaswp(n, a, lda, k1, k2, ipiv, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_claswp(n, a, lda, k1, k2, ipiv, incx)

    CLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_dlaswp(n, a, lda, k1, k2, ipiv, incx)

    DLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_slaswp(n, a, lda, k1, k2, ipiv, incx)

    SLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_zlaswp(n, a, lda, k1, k2, ipiv, incx)

    ZLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: k1
    integer(kind=ilp), intent(in) :: k2
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: incx

public interface lasyf

LASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. LASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    CLASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    DLASYF computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF is an auxiliary routine called by DSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    SLASYF computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF is an auxiliary routine called by SSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    ZLASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface lasyf_aa

DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

  • public pure subroutine clasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)

    DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: j1
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: h(ldh,*)
    integer(kind=ilp), intent(in) :: ldh
    complex(kind=dp), intent(out) :: work(*)

public interface lasyf_rk

LASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    CLASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    DLASYF_RK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF_RK is an auxiliary routine called by DSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    SLASYF_RK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF_RK is an auxiliary routine called by SSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)

    ZLASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLASYF_RK is an auxiliary routine called by ZSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface lasyf_rook

LASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

  • public pure subroutine clasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    CLASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    DLASYF_ROOK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF_ROOK is an auxiliary routine called by DSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    SLASYF_ROOK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF_ROOK is an auxiliary routine called by SSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)

    ZLASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLASYF_ROOK is an auxiliary routine called by ZSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(out) :: kb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
    integer(kind=ilp), intent(out) :: info

public interface latbs

LATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

  • public pure subroutine clatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    CLATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    DLATBS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    SLATBS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)

    ZLATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info

public interface latdf

LATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

  • public pure subroutine clatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(inout) :: rhs(*)
    real(kind=sp), intent(inout) :: rdsum
    real(kind=sp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine dlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: rhs(*)
    real(kind=dp), intent(inout) :: rdsum
    real(kind=dp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine slatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: rhs(*)
    real(kind=sp), intent(inout) :: rdsum
    real(kind=sp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine zlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(inout) :: rhs(*)
    real(kind=dp), intent(inout) :: rdsum
    real(kind=dp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine stdlib_clatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    CLATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(inout) :: rhs(*)
    real(kind=sp), intent(inout) :: rdsum
    real(kind=sp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine stdlib_dlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    DLATDF uses the LU factorization of the n-by-n matrix Z computed by DGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by DGETC2 has the form Z = PLU*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(inout) :: rhs(*)
    real(kind=dp), intent(inout) :: rdsum
    real(kind=dp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine stdlib_slatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    SLATDF uses the LU factorization of the n-by-n matrix Z computed by SGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by SGETC2 has the form Z = PLU*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(inout) :: rhs(*)
    real(kind=sp), intent(inout) :: rdsum
    real(kind=sp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)
  • public pure subroutine stdlib_zlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)

    ZLATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by ZGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by ZGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(inout) :: rhs(*)
    real(kind=dp), intent(inout) :: rdsum
    real(kind=dp), intent(inout) :: rdscal
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(in) :: jpiv(*)

public interface latps

LATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

  • public pure subroutine clatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    CLATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    DLATPS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    SLATPS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)

    ZLATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info

public interface latrd

LATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', LATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', LATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.

  • public pure subroutine clatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine dlatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine slatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine zlatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine stdlib_clatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    CLATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', CLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', CLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine stdlib_dlatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    DLATRD reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', DLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', DLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by DSYTRD.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine stdlib_slatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    SLATRD reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', SLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', SLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by SSYTRD.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw
  • public pure subroutine stdlib_zlatrd(uplo, n, nb, a, lda, e, tau, w, ldw)

    ZLATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', ZLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', ZLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by ZHETRD.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: w(ldw,*)
    integer(kind=ilp), intent(in) :: ldw

public interface latrs

LATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

  • public pure subroutine clatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    CLATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    DLATRS solves one of the triangular systems A x = sb or AT x = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    SLATRS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: x(*)
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)

    ZLATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    character, intent(in) :: normin
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: x(*)
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(inout) :: cnorm(*)
    integer(kind=ilp), intent(out) :: info

public interface latrz

LATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

  • public pure subroutine clatrz(m, n, l, a, lda, tau, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine dlatrz(m, n, l, a, lda, tau, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine slatrz(m, n, l, a, lda, tau, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine zlatrz(m, n, l, a, lda, tau, work)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_clatrz(m, n, l, a, lda, tau, work)

    CLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dlatrz(m, n, l, a, lda, tau, work)

    DLATRZ factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_slatrz(m, n, l, a, lda, tau, work)

    SLATRZ factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_zlatrz(m, n, l, a, lda, tau, work)

    ZLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)

public interface latsqr

LATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

  • public pure subroutine clatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    CLATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    DLATSQR computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    SLATSQR computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    ZLATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface launhr_col_getrfnp

LAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine LAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

  • public pure subroutine claunhr_col_getrfnp(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlaunhr_col_getrfnp(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_claunhr_col_getrfnp(m, n, a, lda, d, info)

    CLAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine CLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlaunhr_col_getrfnp(m, n, a, lda, d, info)

    ZLAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine ZLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface launhr_col_getrfnp2

LAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. LAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, LAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

  • public pure recursive subroutine claunhr_col_getrfnp2(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine zlaunhr_col_getrfnp2(m, n, a, lda, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_claunhr_col_getrfnp2(m, n, a, lda, d, info)

    CLAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. CLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, CLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_zlaunhr_col_getrfnp2(m, n, a, lda, d, info)

    ZLAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. ZLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine ZLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, ZLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without ZLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface lauum

LAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

  • public pure subroutine clauum(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dlauum(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine slauum(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zlauum(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_clauum(uplo, n, a, lda, info)

    CLAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dlauum(uplo, n, a, lda, info)

    DLAUUM computes the product U * UT or LT * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_slauum(uplo, n, a, lda, info)

    SLAUUM computes the product U * UT or LT * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zlauum(uplo, n, a, lda, info)

    ZLAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface opgtr

OPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

  • public pure subroutine dopgtr(uplo, n, ap, tau, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sopgtr(uplo, n, ap, tau, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dopgtr(uplo, n, ap, tau, q, ldq, work, info)

    DOPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sopgtr(uplo, n, ap, tau, q, ldq, work, info)

    SOPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by SSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface opmtr

OPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

  • public pure subroutine dopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    DOPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    SOPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface orbdb

ORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine dorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: tauq2(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: tauq2(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    DORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: tauq2(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    SORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: tauq2(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb1

ORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine dorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    DORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    SORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines SORBDB2, SORBDB3, and SORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb2

ORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine dorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    DORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    SORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines SORBDB1, SORBDB3, and SORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb3

ORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine dorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    DORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    SORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines SORBDB1, SORBDB2, and SORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb4

ORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine dorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: phantom(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: phantom(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    DORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    real(kind=dp), intent(out) :: taup1(*)
    real(kind=dp), intent(out) :: taup2(*)
    real(kind=dp), intent(out) :: tauq1(*)
    real(kind=dp), intent(out) :: phantom(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    SORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines SORBDB1, SORBDB2, and SORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    real(kind=sp), intent(out) :: taup1(*)
    real(kind=sp), intent(out) :: taup2(*)
    real(kind=sp), intent(out) :: tauq1(*)
    real(kind=sp), intent(out) :: phantom(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb5

ORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

  • public pure subroutine dorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    DORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    SORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orbdb6

ORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

  • public pure subroutine dorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    DORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    SORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    real(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    real(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    real(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orcsd

ORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

  • public recursive subroutine dorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine sorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_dorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info)

    DORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_sorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info)

    SORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface orcsd2by1

ORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

  • public subroutine dorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info)

    DORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork, info)

    SORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    real(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    real(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    real(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    real(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface org2l

ORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by DGEQLF.

  • public pure subroutine dorg2l(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorg2l(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorg2l(m, n, k, a, lda, tau, work, info)

    DORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by DGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorg2l(m, n, k, a, lda, tau, work, info)

    SORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by SGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface org2r

ORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

  • public pure subroutine dorg2r(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorg2r(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorg2r(m, n, k, a, lda, tau, work, info)

    DORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorg2r(m, n, k, a, lda, tau, work, info)

    SORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by SGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface orgbr

ORGBR generates one of the real orthogonal matrices Q or PT determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and ORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and ORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and ORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and ORGBR returns PT as an N-by-N matrix.

  • public pure subroutine dorgbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    DORGBR generates one of the real orthogonal matrices Q or PT determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and DORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and DORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and DORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and DORGBR returns PT as an N-by-N matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    SORGBR generates one of the real orthogonal matrices Q or PT determined by SGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and SORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and SORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and SORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and SORGBR returns PT as an N-by-N matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orghr

ORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

  • public pure subroutine dorghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    DORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    SORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orglq

ORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by DGELQF.

  • public pure subroutine dorglq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorglq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorglq(m, n, k, a, lda, tau, work, lwork, info)

    DORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by DGELQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorglq(m, n, k, a, lda, tau, work, lwork, info)

    SORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by SGELQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgql

ORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by DGEQLF.

  • public pure subroutine dorgql(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgql(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgql(m, n, k, a, lda, tau, work, lwork, info)

    DORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by DGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgql(m, n, k, a, lda, tau, work, lwork, info)

    SORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by SGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgqr

ORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

  • public pure subroutine dorgqr(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgqr(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgqr(m, n, k, a, lda, tau, work, lwork, info)

    DORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgqr(m, n, k, a, lda, tau, work, lwork, info)

    SORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by SGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgrq

ORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by DGERQF.

  • public pure subroutine dorgrq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgrq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgrq(m, n, k, a, lda, tau, work, lwork, info)

    DORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by DGERQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgrq(m, n, k, a, lda, tau, work, lwork, info)

    SORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by SGERQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgtr

ORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

  • public pure subroutine dorgtr(uplo, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgtr(uplo, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgtr(uplo, n, a, lda, tau, work, lwork, info)

    DORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgtr(uplo, n, a, lda, tau, work, lwork, info)

    SORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgtsqr

ORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR.

  • public pure subroutine dorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    DORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    SORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by SLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for SLATSQR.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orgtsqr_row

ORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by DLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of DLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine DLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which DLATSQR generates the output blocks.

  • public pure subroutine dorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    DORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by DLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of DLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine DLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which DLATSQR generates the output blocks.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    SORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of SLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by SLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of SLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine SLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which SLATSQR generates the output blocks.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface orhr_col

ORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as DGEQRT).

  • public pure subroutine dorhr_col(m, n, nb, a, lda, t, ldt, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorhr_col(m, n, nb, a, lda, t, ldt, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorhr_col(m, n, nb, a, lda, t, ldt, d, info)

    DORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as DGEQRT).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorhr_col(m, n, nb, a, lda, t, ldt, d, info)

    SORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as SGEQRT).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface orm2l

ORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

  • public pure subroutine dorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    DORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    SORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface orm2r

ORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

  • public pure subroutine dorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    DORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    SORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface ormbr

If VECT = 'Q', ORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', ORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

  • public pure subroutine dormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    If VECT = 'Q', DORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', DORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    If VECT = 'Q', SORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', SORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by SGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormhr

ORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

  • public pure subroutine dormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    DORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    SORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormlq

ORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine dormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    DORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    SORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormql

ORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine dormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    DORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    SORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormqr

ORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine dormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    DORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    SORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormrq

ORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine dormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    DORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    SORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormrz

ORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine dormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    DORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    SORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by STZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ormtr

ORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

  • public pure subroutine dormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    DORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: tau(*)
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    SORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: tau(*)
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface pbcon

PBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info)

    CPBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info)

    DPBCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = UTU or A = LLT computed by DPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info)

    SPBCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = UTU or A = LLT computed by SPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info)

    ZPBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface pbequ

PBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

  • public pure subroutine cpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    CPBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    DPBEQU computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    SPBEQU computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)

    ZPBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface pbrfs

PBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: afb(ldafb,*)
    integer(kind=ilp), intent(in) :: ldafb
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface pbstf

PBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

  • public pure subroutine cpbstf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbstf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbstf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbstf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbstf(uplo, n, kd, ab, ldab, info)

    CPBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbstf(uplo, n, kd, ab, ldab, info)

    DPBSTF computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with DSBGST. The factorization has the form A = S*TS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbstf(uplo, n, kd, ab, ldab, info)

    SPBSTF computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with SSBGST. The factorization has the form A = S*TS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbstf(uplo, n, kd, ab, ldab, info)

    ZPBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with ZHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info

public interface pbsv

PBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    CPBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    DPBSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    SPBSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    ZPBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pbtrf

PBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

  • public pure subroutine cpbtrf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbtrf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbtrf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbtrf(uplo, n, kd, ab, ldab, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbtrf(uplo, n, kd, ab, ldab, info)

    CPBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbtrf(uplo, n, kd, ab, ldab, info)

    DPBTRF computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbtrf(uplo, n, kd, ab, ldab, info)

    SPBTRF computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbtrf(uplo, n, kd, ab, ldab, info)

    ZPBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    integer(kind=ilp), intent(out) :: info

public interface pbtrs

PBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPBTRF.

  • public pure subroutine cpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    CPBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    DPBTRS solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    SPBTRS solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)

    ZPBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UH U or A = LL*H computed by ZPBTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pftrf

PFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine cpftrf(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpftrf(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spftrf(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpftrf(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpftrf(transr, uplo, n, a, info)

    CPFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpftrf(transr, uplo, n, a, info)

    DPFTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spftrf(transr, uplo, n, a, info)

    SPFTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpftrf(transr, uplo, n, a, info)

    ZPFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info

public interface pftri

PFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPFTRF.

  • public pure subroutine cpftri(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpftri(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spftri(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpftri(transr, uplo, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpftri(transr, uplo, n, a, info)

    CPFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpftri(transr, uplo, n, a, info)

    DPFTRI computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spftri(transr, uplo, n, a, info)

    SPFTRI computes the inverse of a real (symmetric) positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpftri(transr, uplo, n, a, info)

    ZPFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info

public interface pftrs

PFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPFTRF.

  • public pure subroutine cpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(0:*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(0:*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    CPFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(0:*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    DPFTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    SPFTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpftrs(transr, uplo, n, nrhs, a, b, ldb, info)

    ZPFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by ZPFTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(0:*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pocon

POCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info)

    CPOCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)

    DPOCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UTU or A = LLT computed by DPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)

    SPOCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UTU or A = LLT computed by SPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info)

    ZPOCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface poequ

POEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

  • public pure subroutine cpoequ(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpoequ(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spoequ(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpoequ(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpoequ(n, a, lda, s, scond, amax, info)

    CPOEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpoequ(n, a, lda, s, scond, amax, info)

    DPOEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spoequ(n, a, lda, s, scond, amax, info)

    SPOEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpoequ(n, a, lda, s, scond, amax, info)

    ZPOEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface poequb

POEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

  • public pure subroutine cpoequb(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpoequb(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spoequb(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpoequb(n, a, lda, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpoequb(n, a, lda, s, scond, amax, info)

    CPOEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpoequb(n, a, lda, s, scond, amax, info)

    DPOEQUB computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from DPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spoequb(n, a, lda, s, scond, amax, info)

    SPOEQUB computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from SPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpoequb(n, a, lda, s, scond, amax, info)

    ZPOEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from ZPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface porfs

PORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CPORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DPORFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SPORFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZPORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface posv

POSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cposv(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dposv(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sposv(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zposv(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cposv(uplo, n, nrhs, a, lda, b, ldb, info)

    CPOSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dposv(uplo, n, nrhs, a, lda, b, ldb, info)

    DPOSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sposv(uplo, n, nrhs, a, lda, b, ldb, info)

    SPOSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zposv(uplo, n, nrhs, a, lda, b, ldb, info)

    ZPOSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface potrf

POTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine cpotrf(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpotrf(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spotrf(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpotrf(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpotrf(uplo, n, a, lda, info)

    CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpotrf(uplo, n, a, lda, info)

    DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spotrf(uplo, n, a, lda, info)

    SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpotrf(uplo, n, a, lda, info)

    ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface potrf2

POTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.

  • public pure recursive subroutine cpotrf2(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine dpotrf2(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine spotrf2(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine zpotrf2(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_cpotrf2(uplo, n, a, lda, info)

    CPOTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_dpotrf2(uplo, n, a, lda, info)

    DPOTRF2 computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_spotrf2(uplo, n, a, lda, info)

    SPOTRF2 computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure recursive subroutine stdlib_zpotrf2(uplo, n, a, lda, info)

    ZPOTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface potri

POTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF.

  • public pure subroutine cpotri(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpotri(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spotri(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpotri(uplo, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpotri(uplo, n, a, lda, info)

    CPOTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpotri(uplo, n, a, lda, info)

    DPOTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spotri(uplo, n, a, lda, info)

    SPOTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpotri(uplo, n, a, lda, info)

    ZPOTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface potrs

POTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPOTRF.

  • public pure subroutine cpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    CPOTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    DPOTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    SPOTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpotrs(uplo, n, nrhs, a, lda, b, ldb, info)

    ZPOTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UH * U or A = L * L*H computed by ZPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface ppcon

PPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cppcon(uplo, n, ap, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dppcon(uplo, n, ap, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sppcon(uplo, n, ap, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zppcon(uplo, n, ap, anorm, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cppcon(uplo, n, ap, anorm, rcond, work, rwork, info)

    CPPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dppcon(uplo, n, ap, anorm, rcond, work, iwork, info)

    DPPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = UTU or A = LLT computed by DPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sppcon(uplo, n, ap, anorm, rcond, work, iwork, info)

    SPPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = UTU or A = LLT computed by SPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zppcon(uplo, n, ap, anorm, rcond, work, rwork, info)

    ZPPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ppequ

PPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

  • public pure subroutine cppequ(uplo, n, ap, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dppequ(uplo, n, ap, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sppequ(uplo, n, ap, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zppequ(uplo, n, ap, s, scond, amax, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cppequ(uplo, n, ap, s, scond, amax, info)

    CPPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dppequ(uplo, n, ap, s, scond, amax, info)

    DPPEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sppequ(uplo, n, ap, s, scond, amax, info)

    SPPEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zppequ(uplo, n, ap, s, scond, amax, info)

    ZPPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    integer(kind=ilp), intent(out) :: info

public interface pprfs

PPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: afp(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: afp(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: afp(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: afp(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ppsv

PPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cppsv(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dppsv(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sppsv(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zppsv(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cppsv(uplo, n, nrhs, ap, b, ldb, info)

    CPPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dppsv(uplo, n, nrhs, ap, b, ldb, info)

    DPPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sppsv(uplo, n, nrhs, ap, b, ldb, info)

    SPPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zppsv(uplo, n, nrhs, ap, b, ldb, info)

    ZPPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pptrf

PPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

  • public pure subroutine cpptrf(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpptrf(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spptrf(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpptrf(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpptrf(uplo, n, ap, info)

    CPPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpptrf(uplo, n, ap, info)

    DPPTRF computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spptrf(uplo, n, ap, info)

    SPPTRF computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpptrf(uplo, n, ap, info)

    ZPPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info

public interface pptri

PPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF.

  • public pure subroutine cpptri(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpptri(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spptri(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpptri(uplo, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpptri(uplo, n, ap, info)

    CPPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpptri(uplo, n, ap, info)

    DPPTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spptri(uplo, n, ap, info)

    SPPTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpptri(uplo, n, ap, info)

    ZPPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info

public interface pptrs

PPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UHU or A = LL*H computed by CPPTRF.

  • public pure subroutine cpptrs(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpptrs(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spptrs(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpptrs(uplo, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpptrs(uplo, n, nrhs, ap, b, ldb, info)

    CPPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UHU or A = LL*H computed by CPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpptrs(uplo, n, nrhs, ap, b, ldb, info)

    DPPTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = UTU or A = LL*T computed by DPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spptrs(uplo, n, nrhs, ap, b, ldb, info)

    SPPTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = UTU or A = LL*T computed by SPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpptrs(uplo, n, nrhs, ap, b, ldb, info)

    ZPPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UH * U or A = L * L*H computed by ZPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pstrf

PSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

  • public pure subroutine cpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    CPSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    DPSTRF computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form PT * A * P = UT * U , if UPLO = 'U', PT * A * P = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    SPSTRF computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form PT * A * P = UT * U , if UPLO = 'U', PT * A * P = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=sp), intent(in) :: tol
    real(kind=sp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpstrf(uplo, n, a, lda, piv, rank, tol, work, info)

    ZPSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: piv(n)
    integer(kind=ilp), intent(out) :: rank
    real(kind=dp), intent(in) :: tol
    real(kind=dp), intent(out) :: work(2*n)
    integer(kind=ilp), intent(out) :: info

public interface ptcon

PTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cptcon(n, d, e, anorm, rcond, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dptcon(n, d, e, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sptcon(n, d, e, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zptcon(n, d, e, anorm, rcond, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cptcon(n, d, e, anorm, rcond, rwork, info)

    CPTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dptcon(n, d, e, anorm, rcond, work, info)

    DPTCON computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = LDLT or A = UTDU computed by DPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sptcon(n, d, e, anorm, rcond, work, info)

    SPTCON computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = LDLT or A = UTDU computed by SPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zptcon(n, d, e, anorm, rcond, rwork, info)

    ZPTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by ZPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface pteqr

PTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

  • public pure subroutine cpteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpteqr(compz, n, d, e, z, ldz, work, info)

    CPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpteqr(compz, n, d, e, z, ldz, work, info)

    DPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using DPTTRF, and then calling DBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band symmetric positive definite matrix can also be found if DSYTRD, DSPTRD, or DSBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spteqr(compz, n, d, e, z, ldz, work, info)

    SPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF, and then calling SBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band symmetric positive definite matrix can also be found if SSYTRD, SSPTRD, or SSBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpteqr(compz, n, d, e, z, ldz, work, info)

    ZPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using DPTTRF and then calling ZBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if ZHETRD, ZHPTRD, or ZHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface ptrfs

PTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine cptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: df(*)
    complex(kind=sp), intent(in) :: ef(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: df(*)
    real(kind=dp), intent(in) :: ef(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: df(*)
    real(kind=sp), intent(in) :: ef(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: df(*)
    complex(kind=dp), intent(in) :: ef(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: df(*)
    complex(kind=sp), intent(in) :: ef(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)

    DPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: df(*)
    real(kind=dp), intent(in) :: ef(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)

    SPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(in) :: df(*)
    real(kind=sp), intent(in) :: ef(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(in) :: df(*)
    complex(kind=dp), intent(in) :: ef(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ptsv

PTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.

  • public pure subroutine cptsv(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dptsv(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sptsv(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zptsv(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cptsv(n, nrhs, d, e, b, ldb, info)

    CPTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dptsv(n, nrhs, d, e, b, ldb, info)

    DPTSV computes the solution to a real system of linear equations AX = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*T, and the factored form of A is then used to solve the system of equations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sptsv(n, nrhs, d, e, b, ldb, info)

    SPTSV computes the solution to a real system of linear equations AX = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*T, and the factored form of A is then used to solve the system of equations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zptsv(n, nrhs, d, e, b, ldb, info)

    ZPTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface pttrf

PTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.

  • public pure subroutine cpttrf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpttrf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spttrf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpttrf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpttrf(n, d, e, info)

    CPTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpttrf(n, d, e, info)

    DPTTRF computes the LDLT factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UTDU.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spttrf(n, d, e, info)

    SPTTRF computes the LDLT factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UTDU.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpttrf(n, d, e, info)

    ZPTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info

public interface pttrs

PTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UHDU or A = LDLH computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

  • public pure subroutine cpttrs(uplo, n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dpttrs(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine spttrs(n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zpttrs(uplo, n, nrhs, d, e, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cpttrs(uplo, n, nrhs, d, e, b, ldb, info)

    CPTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UHDU or A = LDLH computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    complex(kind=sp), intent(in) :: e(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dpttrs(n, nrhs, d, e, b, ldb, info)

    DPTTRS solves a tridiagonal system of the form A * X = B using the LDL**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_spttrs(n, nrhs, d, e, b, ldb, info)

    SPTTRS solves a tridiagonal system of the form A * X = B using the LDL**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zpttrs(uplo, n, nrhs, d, e, b, ldb, info)

    ZPTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UH D U or A = LDLH computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: d(*)
    complex(kind=dp), intent(in) :: e(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface rot

ROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

  • public pure subroutine crot(n, cx, incx, cy, incy, c, s)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c
    complex(kind=sp), intent(in) :: s
  • public pure subroutine zrot(n, cx, incx, cy, incy, c, s)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c
    complex(kind=dp), intent(in) :: s
  • public pure subroutine stdlib_crot(n, cx, incx, cy, incy, c, s)

    CROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=sp), intent(in) :: c
    complex(kind=sp), intent(in) :: s
  • public pure subroutine stdlib_zrot(n, cx, incx, cy, incy, c, s)

    ZROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: cx(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: cy(*)
    integer(kind=ilp), intent(in) :: incy
    real(kind=dp), intent(in) :: c
    complex(kind=dp), intent(in) :: s

public interface rscl

RSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.

  • public pure subroutine drscl(n, sa, sx, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: sa
    real(kind=dp), intent(inout) :: sx(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine srscl(n, sa, sx, incx)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: sa
    real(kind=sp), intent(inout) :: sx(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_drscl(n, sa, sx, incx)

    DRSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: sa
    real(kind=dp), intent(inout) :: sx(*)
    integer(kind=ilp), intent(in) :: incx
  • public pure subroutine stdlib_srscl(n, sa, sx, incx)

    SRSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: sa
    real(kind=sp), intent(inout) :: sx(*)
    integer(kind=ilp), intent(in) :: incx

public interface sb2st_kernels

SB2ST_KERNELS is an internal routine used by the DSYTRD_SB2ST subroutine.

  • public pure subroutine dsb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: v(*)
    real(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine ssb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: v(*)
    real(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)
  • public pure subroutine stdlib_dsb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    DSB2ST_KERNELS is an internal routine used by the DSYTRD_SB2ST subroutine.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: v(*)
    real(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=dp), intent(out) :: work(*)
  • public pure subroutine stdlib_ssb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)

    SSB2ST_KERNELS is an internal routine used by the SSYTRD_SB2ST subroutine.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: ttype
    integer(kind=ilp), intent(in) :: st
    integer(kind=ilp), intent(in) :: ed
    integer(kind=ilp), intent(in) :: sweep
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    integer(kind=ilp), intent(in) :: ib
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: v(*)
    real(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(in) :: ldvt
    real(kind=sp), intent(out) :: work(*)

public interface sbev

SBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.

  • public subroutine dsbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)

    DSBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)

    SSBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sbevd

SBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine dsbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)

    DSBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)

    SSBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface sbgst

SBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by DPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.

  • public pure subroutine dsbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info)

    DSBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by DPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info)

    SSBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by SPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sbgv

SBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.

  • public pure subroutine dsbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)

    DSBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)

    SSBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sbgvd

SBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public pure subroutine dsbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)

    DSBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)

    SSBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ka
    integer(kind=ilp), intent(in) :: kb
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: bb(ldbb,*)
    integer(kind=ilp), intent(in) :: ldbb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface sbtrd

SBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

  • public pure subroutine dsbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    DSBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)

    SSBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sfrk

Level 3 BLAS like routine for C in RFP Format. SFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

  • public pure subroutine dsfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: c(*)
  • public pure subroutine ssfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: c(*)
  • public pure subroutine stdlib_dsfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Level 3 BLAS like routine for C in RFP Format. DSFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: beta
    real(kind=dp), intent(inout) :: c(*)
  • public pure subroutine stdlib_ssfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c)

    Level 3 BLAS like routine for C in RFP Format. SSFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: beta
    real(kind=sp), intent(inout) :: c(*)

public interface spcon

SPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine cspcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zspcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cspcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    CSPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info)

    DSPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by DSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info)

    SSPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by SSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zspcon(uplo, n, ap, ipiv, anorm, rcond, work, info)

    ZSPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by ZSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface spev

SPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.

  • public subroutine dspev(jobz, uplo, n, ap, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sspev(jobz, uplo, n, ap, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dspev(jobz, uplo, n, ap, w, z, ldz, work, info)

    DSPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sspev(jobz, uplo, n, ap, w, z, ldz, work, info)

    SSPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface spevd

SPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine dspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)

    DSPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)

    SSPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface spgst

SPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPPTRF.

  • public pure subroutine dspgst(itype, uplo, n, ap, bp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sspgst(itype, uplo, n, ap, bp, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dspgst(itype, uplo, n, ap, bp, info)

    DSPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sspgst(itype, uplo, n, ap, bp, info)

    SSPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by SPPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(in) :: bp(*)
    integer(kind=ilp), intent(out) :: info

public interface spgv

SPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.

  • public subroutine dspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine sspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)

    DSPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)

    SSPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface spgvd

SPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine dspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine sspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)

    DSPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(inout) :: bp(*)
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_sspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)

    SSPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(inout) :: bp(*)
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface spmv

SPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

  • public pure subroutine cspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine zspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine stdlib_cspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

    CSPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine stdlib_zspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

    ZSPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface spr

SPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

  • public pure subroutine cspr(uplo, n, alpha, x, incx, ap)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: ap(*)
  • public pure subroutine zspr(uplo, n, alpha, x, incx, ap)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: ap(*)
  • public pure subroutine stdlib_cspr(uplo, n, alpha, x, incx, ap)

    CSPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: ap(*)
  • public pure subroutine stdlib_zspr(uplo, n, alpha, x, incx, ap)

    ZSPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: ap(*)

public interface sprfs

SPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine csprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: afp(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface spsv

SPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine cspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    CSPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    DSPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    SSPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    ZSPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface sptrd

SPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

  • public pure subroutine dsptrd(uplo, n, ap, d, e, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssptrd(uplo, n, ap, d, e, tau, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsptrd(uplo, n, ap, d, e, tau, info)

    DSPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssptrd(uplo, n, ap, d, e, tau, info)

    SSPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    integer(kind=ilp), intent(out) :: info

public interface sptrf

SPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

  • public pure subroutine csptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsptrf(uplo, n, ap, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csptrf(uplo, n, ap, ipiv, info)

    CSPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsptrf(uplo, n, ap, ipiv, info)

    DSPTRF computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssptrf(uplo, n, ap, ipiv, info)

    SSPTRF computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsptrf(uplo, n, ap, ipiv, info)

    ZSPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface sptri

SPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by CSPTRF.

  • public pure subroutine csptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsptri(uplo, n, ap, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csptri(uplo, n, ap, ipiv, work, info)

    CSPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by CSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsptri(uplo, n, ap, ipiv, work, info)

    DSPTRI computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by DSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssptri(uplo, n, ap, ipiv, work, info)

    SSPTRI computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by SSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsptri(uplo, n, ap, ipiv, work, info)

    ZSPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by ZSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sptrs

SPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.

  • public pure subroutine csptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    CSPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    DSPTRS solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by DSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    SSPTRS solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by SSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info)

    ZSPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by ZSPTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface stebz

STEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

  • public pure subroutine dstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(out) :: m
    integer(kind=ilp), intent(out) :: nsplit
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: isplit(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(out) :: m
    integer(kind=ilp), intent(out) :: nsplit
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: isplit(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info)

    DSTEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(out) :: m
    integer(kind=ilp), intent(out) :: nsplit
    real(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: isplit(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info)

    SSTEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: range
    character, intent(in) :: order
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(out) :: m
    integer(kind=ilp), intent(out) :: nsplit
    real(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: iblock(*)
    integer(kind=ilp), intent(out) :: isplit(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface stedc

STEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.

  • public pure subroutine cstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    CSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    DSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band real symmetric matrix can also be found if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAED3 for details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    SSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band real symmetric matrix can also be found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)

    ZSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAED3 for details.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface stegr

STEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. STEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : STEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

  • public pure subroutine cstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    CSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. CSTEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : CSTEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    DSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. DSTEGR is a compatibility wrapper around the improved DSTEMR routine. See DSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : DSTEGR and DSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    SSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. SSTEGR is a compatibility wrapper around the improved SSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : SSTEGR and SSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    ZSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. ZSTEGR is a compatibility wrapper around the improved ZSTEMR routine. See ZSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : ZSTEGR and ZSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface stein

STEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.

  • public pure subroutine cstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    CSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    DSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    SSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: d(*)
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=sp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)

    ZSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to ZUNMTR or ZUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: d(*)
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: m
    real(kind=dp), intent(in) :: w(*)
    integer(kind=ilp), intent(in) :: iblock(*)
    integer(kind=ilp), intent(in) :: isplit(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: ifail(*)
    integer(kind=ilp), intent(out) :: info

public interface stemr

STEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.STEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, STEMR accepts complex workspace to facilitate interoperability with CUNMTR or CUPMTR.

  • public pure subroutine cstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    CSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.CSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, CSTEMR accepts complex workspace to facilitate interoperability with CUNMTR or CUPMTR.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    complex(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    DSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.DSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    SSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.SSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)

    ZSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.ZSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, ZSTEMR accepts complex workspace to facilitate interoperability with ZUNMTR or ZUPMTR.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    complex(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: nzc
    integer(kind=ilp), intent(out) :: isuppz(*)
    logical(kind=lk), intent(inout) :: tryrac
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface steqr

STEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.

  • public pure subroutine csteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsteqr(compz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csteqr(compz, n, d, e, z, ldz, work, info)

    CSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsteqr(compz, n, d, e, z, ldz, work, info)

    DSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band symmetric matrix can also be found if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssteqr(compz, n, d, e, z, ldz, work, info)

    SSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band symmetric matrix can also be found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this matrix to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsteqr(compz, n, d, e, z, ldz, work, info)

    ZSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this matrix to tridiagonal form.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sterf

STERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.

  • public pure subroutine dsterf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssterf(n, d, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsterf(n, d, e, info)

    DSTERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssterf(n, d, e, info)

    SSTERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(out) :: info

public interface stev

STEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.

  • public pure subroutine dstev(jobz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstev(jobz, n, d, e, z, ldz, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstev(jobz, n, d, e, z, ldz, work, info)

    DSTEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstev(jobz, n, d, e, z, ldz, work, info)

    SSTEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface stevd

STEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public pure subroutine dstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    DSTEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info)

    SSTEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface stevr

STEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, STEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : STEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. STEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

  • public pure subroutine dstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine sstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    DSTEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, DSTEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : DSTEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. DSTEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: d(*)
    real(kind=dp), intent(inout) :: e(*)
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_sstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    SSTEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, SSTEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : SSTEVR calls SSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SSTEVR calls SSTEBZ and SSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of SSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: d(*)
    real(kind=sp), intent(inout) :: e(*)
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface sycon

SYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine csycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    CSYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    DSYCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    SSYCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    ZSYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sycon_rook

SYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

  • public pure subroutine csycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    CSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    DSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)

    SSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: anorm
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info)

    ZSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: anorm
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface syconv

SYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

  • public pure subroutine csyconv(uplo, way, n, a, lda, ipiv, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsyconv(uplo, way, n, a, lda, ipiv, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssyconv(uplo, way, n, a, lda, ipiv, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsyconv(uplo, way, n, a, lda, ipiv, e, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csyconv(uplo, way, n, a, lda, ipiv, e, info)

    CSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsyconv(uplo, way, n, a, lda, ipiv, e, info)

    DSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssyconv(uplo, way, n, a, lda, ipiv, e, info)

    SSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsyconv(uplo, way, n, a, lda, ipiv, e, info)

    ZSYCONV converts A given by ZHETRF into L and D or vice-versa. Get nondiagonal elements of D (returned in workspace) and apply or reverse permutation done in TRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: info

public interface syconvf

If parameter WAY = 'C': SYCONVF converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': SYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. SYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).

  • public pure subroutine csyconvf(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsyconvf(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssyconvf(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsyconvf(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csyconvf(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': CSYCONVF converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': CSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. CSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsyconvf(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': DSYCONVF converts the factorization output format used in DSYTRF provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF into the format used in DSYTRF_RK (or DSYTRF_BK). If parameter WAY = 'R': DSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF_RK (or DSYTRF_BK) into the format used in DSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssyconvf(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': SSYCONVF converts the factorization output format used in SSYTRF provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF into the format used in SSYTRF_RK (or SSYTRF_BK). If parameter WAY = 'R': SSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF_RK (or SSYTRF_BK) into the format used in SSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsyconvf(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': ZSYCONVF converts the factorization output format used in ZSYTRF provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF into the format used in ZSYTRF_RK (or ZSYTRF_BK). If parameter WAY = 'R': ZSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF_RK (or ZSYTRF_BK) into the format used in ZSYTRF. ZSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF and ZHETRF_RK (or ZHETRF_BK).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(inout) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface syconvf_rook

If parameter WAY = 'C': SYCONVF_ROOK converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': SYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. SYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).

  • public pure subroutine csyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': CSYCONVF_ROOK converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': CSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': DSYCONVF_ROOK converts the factorization output format used in DSYTRF_ROOK provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': DSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF_ROOK that is stored on exit in parameter A. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': SSYCONVF_ROOK converts the factorization output format used in SSYTRF_ROOK provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': SSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF_ROOK that is stored on exit in parameter A. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info)

    If parameter WAY = 'C': ZSYCONVF_ROOK converts the factorization output format used in ZSYTRF_ROOK provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': ZSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF_ROOK that is stored on exit in parameter A. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. ZSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF_ROOK and ZHETRF_RK (or ZHETRF_BK).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: way
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface syequb

SYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

  • public pure subroutine csyequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsyequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssyequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsyequb(uplo, n, a, lda, s, scond, amax, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csyequb(uplo, n, a, lda, s, scond, amax, work, info)

    CSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsyequb(uplo, n, a, lda, s, scond, amax, work, info)

    DSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssyequb(uplo, n, a, lda, s, scond, amax, work, info)

    SSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: scond
    real(kind=sp), intent(out) :: amax
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsyequb(uplo, n, a, lda, s, scond, amax, work, info)

    ZSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: scond
    real(kind=dp), intent(out) :: amax
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface syev

SYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

  • public subroutine dsyev(jobz, uplo, n, a, lda, w, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssyev(jobz, uplo, n, a, lda, w, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsyev(jobz, uplo, n, a, lda, w, work, lwork, info)

    DSYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssyev(jobz, uplo, n, a, lda, w, work, lwork, info)

    SSYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface syevd

SYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, SYEVD needs N**2 more workspace than DSYEVX.

  • public subroutine dsyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)

    DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, DSYEVD needs N**2 more workspace than DSYEVX.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)

    SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, SSYEVD needs N**2 more workspace than SSYEVX.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface syevr

SYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, SYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : SYEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SYEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

  • public subroutine dsyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    DSYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. DSYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : DSYEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. DSYEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: vl
    real(kind=dp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=dp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)

    SSYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SSYEVR first reduces the matrix A to tridiagonal form T with a call to SSYTRD. Then, whenever possible, SSYEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see SSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : SSYEVR calls SSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SSYEVR calls SSTEBZ and SSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of SSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobz
    character, intent(in) :: range
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: vl
    real(kind=sp), intent(in) :: vu
    integer(kind=ilp), intent(in) :: il
    integer(kind=ilp), intent(in) :: iu
    real(kind=sp), intent(in) :: abstol
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: isuppz(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface sygst

SYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPOTRF.

  • public pure subroutine dsygst(itype, uplo, n, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssygst(itype, uplo, n, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsygst(itype, uplo, n, a, lda, b, ldb, info)

    DSYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssygst(itype, uplo, n, a, lda, b, ldb, info)

    SSYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by SPOTRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface sygv

SYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.

  • public subroutine dsygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)

    DSYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)

    SSYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sygvd

SYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

  • public subroutine dsygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ssygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dsygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)

    DSYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: w(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ssygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)

    SSYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: itype
    character, intent(in) :: jobz
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: w(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface symv

SYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.

  • public pure subroutine csymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine zsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine stdlib_csymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    CSYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(in) :: beta
    complex(kind=sp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy
  • public pure subroutine stdlib_zsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

    ZSYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(in) :: beta
    complex(kind=dp), intent(inout) :: y(*)
    integer(kind=ilp), intent(in) :: incy

public interface syr

SYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.

  • public pure subroutine csyr(uplo, n, alpha, x, incx, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine zsyr(uplo, n, alpha, x, incx, a, lda)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_csyr(uplo, n, alpha, x, incx, a, lda)

    CSYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
  • public pure subroutine stdlib_zsyr(uplo, n, alpha, x, incx, a, lda)

    ZSYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: x(*)
    integer(kind=ilp), intent(in) :: incx
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda

public interface syrfs

SYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

  • public pure subroutine csyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    SSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: af(ldaf,*)
    integer(kind=ilp), intent(in) :: ldaf
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface sysv

SYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine csysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    DSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    SSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sysv_aa

CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

  • public pure subroutine csysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    DSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    SSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sysv_rk

SYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.

  • public pure subroutine csysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    CSYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    DSYSV_RK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. DSYTRF_RK is called to compute the factorization of a real symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine DSYTRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    SSYSV_RK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. SSYTRF_RK is called to compute the factorization of a real symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine SSYTRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)

    ZSYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine ZSYTRS_3.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sysv_rook

SYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CSYTRS_ROOK.

  • public pure subroutine csysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CSYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CSYTRS_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    DSYSV_ROOK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. DSYTRF_ROOK is called to compute the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling DSYTRS_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    SSYSV_ROOK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. SSYTRF_ROOK is called to compute the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling SSYTRS_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZSYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling ZSYTRS_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface syswapr

SYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.

  • public pure subroutine csyswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine dsyswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine ssyswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine zsyswapr(uplo, n, a, lda, i1, i2)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_csyswapr(uplo, n, a, lda, i1, i2)

    CSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_dsyswapr(uplo, n, a, lda, i1, i2)

    DSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_ssyswapr(uplo, n, a, lda, i1, i2)

    SSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2
  • public pure subroutine stdlib_zsyswapr(uplo, n, a, lda, i1, i2)

    ZSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,n)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: i1
    integer(kind=ilp), intent(in) :: i2

public interface sytf2_rk

SYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

  • public pure subroutine csytf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytf2_rk(uplo, n, a, lda, e, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytf2_rk(uplo, n, a, lda, e, ipiv, info)

    CSYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytf2_rk(uplo, n, a, lda, e, ipiv, info)

    DSYTF2_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytf2_rk(uplo, n, a, lda, e, ipiv, info)

    SSYTF2_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytf2_rk(uplo, n, a, lda, e, ipiv, info)

    ZSYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface sytf2_rook

SYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

  • public pure subroutine csytf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytf2_rook(uplo, n, a, lda, ipiv, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytf2_rook(uplo, n, a, lda, ipiv, info)

    CSYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytf2_rook(uplo, n, a, lda, ipiv, info)

    DSYTF2_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytf2_rook(uplo, n, a, lda, ipiv, info)

    SSYTF2_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytf2_rook(uplo, n, a, lda, ipiv, info)

    ZSYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    integer(kind=ilp), intent(out) :: info

public interface sytrd

SYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

  • public pure subroutine dsytrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    DSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrd(uplo, n, a, lda, d, e, tau, work, lwork, info)

    SSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrd_sb2st

SYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.

  • public pure subroutine dsytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    DSYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: d(*)
    real(kind=dp), intent(out) :: e(*)
    real(kind=dp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)

    SSYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: stage1
    character, intent(in) :: vect
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: d(*)
    real(kind=sp), intent(out) :: e(*)
    real(kind=sp), intent(out) :: hous(*)
    integer(kind=ilp), intent(in) :: lhous
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrd_sy2sb

SYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.

  • public pure subroutine dsytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    DSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)

    SSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrf

SYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine csytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    CSYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    DSYTRF computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UTDU or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    SSYTRF computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UTDU or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrf(uplo, n, a, lda, ipiv, work, lwork, info)

    ZSYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrf_aa

SYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine csytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    CSYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    DSYTRF_AA computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    SSYTRF_AA computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info)

    ZSYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrf_rk

SYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

  • public pure subroutine csytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    CSYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    DSYTRF_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    SSYTRF_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info)

    ZSYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: e(*)
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrf_rook

SYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

  • public pure subroutine csytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    CSYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    DSYTRF_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    SSYTRF_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info)

    ZSYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytri

SYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF.

  • public pure subroutine csytri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytri(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytri(uplo, n, a, lda, ipiv, work, info)

    CSYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytri(uplo, n, a, lda, ipiv, work, info)

    DSYTRI computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytri(uplo, n, a, lda, ipiv, work, info)

    SSYTRI computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytri(uplo, n, a, lda, ipiv, work, info)

    ZSYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sytri_rook

SYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK.

  • public pure subroutine csytri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytri_rook(uplo, n, a, lda, ipiv, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytri_rook(uplo, n, a, lda, ipiv, work, info)

    CSYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytri_rook(uplo, n, a, lda, ipiv, work, info)

    DSYTRI_ROOK computes the inverse of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytri_rook(uplo, n, a, lda, ipiv, work, info)

    SSYTRI_ROOK computes the inverse of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytri_rook(uplo, n, a, lda, ipiv, work, info)

    ZSYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sytrs

SYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF.

  • public pure subroutine csytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    CSYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    DSYTRS solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    SSYTRS solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    ZSYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface sytrs2

SYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF and converted by CSYCONV.

  • public pure subroutine csytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    CSYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF and converted by CSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    DSYTRS2 solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF and converted by DSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    SSYTRS2 solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF and converted by SSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)

    ZSYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF and converted by ZSYCONV.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface sytrs_3

SYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

  • public pure subroutine csytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    CSYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    DSYTRS_3 solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by DSYTRF_RK or DSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    SSYTRS_3 solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by SSYTRF_RK or SSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)

    ZSYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by ZSYTRF_RK or ZSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: e(*)
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface sytrs_aa

SYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.

  • public pure subroutine csytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    CSYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    DSYTRS_AA solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by DSYTRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    SSYTRS_AA solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by SSYTRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)

    ZSYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by ZSYTRF_AA.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface sytrs_rook

SYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.

  • public pure subroutine csytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ssytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_csytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    CSYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    DSYTRS_ROOK solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ssytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    SSYTRS_ROOK solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info)

    ZSYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF_ROOK.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(in) :: ipiv(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface tbcon

TBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

  • public subroutine ctbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine ztbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ctbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)

    CTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)

    DTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_stbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)

    STBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ztbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)

    ZTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tbrfs

TBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. TBRFS does not do iterative refinement because doing so cannot improve the backward error.

  • public pure subroutine ctbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by DTBTRS or some other means before entering this routine. DTBRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    STBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by STBTRS or some other means before entering this routine. STBRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by ZTBTRS or some other means before entering this routine. ZTBRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tbtrs

TBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

  • public pure subroutine ctbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    CTBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    DTBTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    STBTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)

    ZTBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: kd
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ab(ldab,*)
    integer(kind=ilp), intent(in) :: ldab
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface tfsm

Level 3 BLAS like routine for A in RFP Format. TFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

  • public pure subroutine ctfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(0:*)
    complex(kind=sp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine dtfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine ztfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(0:*)
    complex(kind=dp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_ctfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Level 3 BLAS like routine for A in RFP Format. CTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: alpha
    complex(kind=sp), intent(in) :: a(0:*)
    complex(kind=sp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_dtfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Level 3 BLAS like routine for A in RFP Format. DTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: alpha
    real(kind=dp), intent(in) :: a(0:*)
    real(kind=dp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_stfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Level 3 BLAS like routine for A in RFP Format. STFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: alpha
    real(kind=sp), intent(in) :: a(0:*)
    real(kind=sp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb
  • public pure subroutine stdlib_ztfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)

    Level 3 BLAS like routine for A in RFP Format. ZTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: alpha
    complex(kind=dp), intent(in) :: a(0:*)
    complex(kind=dp), intent(inout) :: b(0:ldb-1,0:*)
    integer(kind=ilp), intent(in) :: ldb

public interface tftri

TFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

  • public pure subroutine ctftri(transr, uplo, diag, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtftri(transr, uplo, diag, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stftri(transr, uplo, diag, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztftri(transr, uplo, diag, n, a, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctftri(transr, uplo, diag, n, a, info)

    CTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtftri(transr, uplo, diag, n, a, info)

    DTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stftri(transr, uplo, diag, n, a, info)

    STFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztftri(transr, uplo, diag, n, a, info)

    ZTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(0:*)
    integer(kind=ilp), intent(out) :: info

public interface tfttp

TFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

  • public pure subroutine ctfttp(transr, uplo, n, arf, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: arf(0:*)
    complex(kind=sp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtfttp(transr, uplo, n, arf, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: arf(0:*)
    real(kind=dp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stfttp(transr, uplo, n, arf, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: arf(0:*)
    real(kind=sp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztfttp(transr, uplo, n, arf, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: arf(0:*)
    complex(kind=dp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctfttp(transr, uplo, n, arf, ap, info)

    CTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: arf(0:*)
    complex(kind=sp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtfttp(transr, uplo, n, arf, ap, info)

    DTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: arf(0:*)
    real(kind=dp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stfttp(transr, uplo, n, arf, ap, info)

    STFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: arf(0:*)
    real(kind=sp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztfttp(transr, uplo, n, arf, ap, info)

    ZTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: arf(0:*)
    complex(kind=dp), intent(out) :: ap(0:*)
    integer(kind=ilp), intent(out) :: info

public interface tfttr

TFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

  • public pure subroutine ctfttr(transr, uplo, n, arf, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: arf(0:*)
    complex(kind=sp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtfttr(transr, uplo, n, arf, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: arf(0:*)
    real(kind=dp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stfttr(transr, uplo, n, arf, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: arf(0:*)
    real(kind=sp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztfttr(transr, uplo, n, arf, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: arf(0:*)
    complex(kind=dp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctfttr(transr, uplo, n, arf, a, lda, info)

    CTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: arf(0:*)
    complex(kind=sp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtfttr(transr, uplo, n, arf, a, lda, info)

    DTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: arf(0:*)
    real(kind=dp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stfttr(transr, uplo, n, arf, a, lda, info)

    STFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: arf(0:*)
    real(kind=sp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztfttr(transr, uplo, n, arf, a, lda, info)

    ZTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: arf(0:*)
    complex(kind=dp), intent(out) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface tgevc

TGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).

  • public pure subroutine ctgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    complex(kind=sp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    real(kind=dp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    real(kind=sp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    complex(kind=dp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    CTGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    complex(kind=sp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info)

    DTGEVC computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = QSZT, B = QPZT as computed by DGGHRD + DHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    real(kind=dp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info)

    STGEVC computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = QSZT, B = QPZT as computed by SGGHRD + SHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    real(kind=sp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    ZTGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by ZGGHRD + ZHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: s(lds,*)
    integer(kind=ilp), intent(in) :: lds
    complex(kind=dp), intent(in) :: p(ldp,*)
    integer(kind=ilp), intent(in) :: ldp
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tgexc

TGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H

  • public pure subroutine ctgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)

    CTGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)

    DTGEXC reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * ZT, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)T = Q(out) * A(out) * Z(out)T Q(in) * B(in) * Z(in)T = Q(out) * B(out) * Z(out)**T

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)

    STGEXC reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * ZT, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)T = Q(out) * A(out) * Z(out)T Q(in) * B(in) * Z(in)T = Q(out) * B(out) * Z(out)**T

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)

    ZTGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H

    Arguments

    TypeIntentOptionalAttributesName
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    integer(kind=ilp), intent(out) :: info

public interface tgsen

TGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. TGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

  • public pure subroutine ctgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: pl
    real(kind=sp), intent(out) :: pr
    real(kind=sp), intent(out) :: dif(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: pl
    real(kind=dp), intent(out) :: pr
    real(kind=dp), intent(out) :: dif(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: pl
    real(kind=sp), intent(out) :: pr
    real(kind=sp), intent(out) :: dif(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: pl
    real(kind=dp), intent(out) :: pr
    real(kind=dp), intent(out) :: dif(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    CTGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: alpha(*)
    complex(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: pl
    real(kind=sp), intent(out) :: pr
    real(kind=sp), intent(out) :: dif(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    DTGSEN reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q*T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. DTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + iALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, DTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: alphar(*)
    real(kind=dp), intent(out) :: alphai(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: pl
    real(kind=dp), intent(out) :: pr
    real(kind=dp), intent(out) :: dif(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    STGSEN reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q*T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. STGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + iALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, STGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: alphar(*)
    real(kind=sp), intent(out) :: alphai(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: pl
    real(kind=sp), intent(out) :: pr
    real(kind=sp), intent(out) :: dif(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)

    ZTGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. ZTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: ijob
    logical(kind=lk), intent(in) :: wantq
    logical(kind=lk), intent(in) :: wantz
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: alpha(*)
    complex(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(inout) :: z(ldz,*)
    integer(kind=ilp), intent(in) :: ldz
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: pl
    real(kind=dp), intent(out) :: pr
    real(kind=dp), intent(out) :: dif(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info

public interface tgsja

TGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

  • public pure subroutine ctgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: tola
    real(kind=sp), intent(in) :: tolb
    real(kind=sp), intent(out) :: alpha(*)
    real(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: tola
    real(kind=dp), intent(in) :: tolb
    real(kind=dp), intent(out) :: alpha(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: tola
    real(kind=sp), intent(in) :: tolb
    real(kind=sp), intent(out) :: alpha(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: tola
    real(kind=dp), intent(in) :: tolb
    real(kind=dp), intent(out) :: alpha(*)
    real(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    CTGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: tola
    real(kind=sp), intent(in) :: tolb
    real(kind=sp), intent(out) :: alpha(*)
    real(kind=sp), intent(out) :: beta(*)
    complex(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    DTGSJA computes the generalized singular value decomposition (GSVD) of two real upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine DGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UT AQ = D1*( 0 R ), VT BQ = D2( 0 R ), where U, V and Q are orthogonal matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the orthogonal transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: tola
    real(kind=dp), intent(in) :: tolb
    real(kind=dp), intent(out) :: alpha(*)
    real(kind=dp), intent(out) :: beta(*)
    real(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    STGSJA computes the generalized singular value decomposition (GSVD) of two real upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine SGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UT AQ = D1*( 0 R ), VT BQ = D2( 0 R ), where U, V and Q are orthogonal matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the orthogonal transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: tola
    real(kind=sp), intent(in) :: tolb
    real(kind=sp), intent(out) :: alpha(*)
    real(kind=sp), intent(out) :: beta(*)
    real(kind=sp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    real(kind=sp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)

    ZTGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine ZGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu
    character, intent(in) :: jobv
    character, intent(in) :: jobq
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: tola
    real(kind=dp), intent(in) :: tolb
    real(kind=dp), intent(out) :: alpha(*)
    real(kind=dp), intent(out) :: beta(*)
    complex(kind=dp), intent(inout) :: u(ldu,*)
    integer(kind=ilp), intent(in) :: ldu
    complex(kind=dp), intent(inout) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: ncycle
    integer(kind=ilp), intent(out) :: info

public interface tgsna

TGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.

  • public pure subroutine ctgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    CTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    DTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (QAZT, QBZT) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    STGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (QAZT, QBZT) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)

    ZTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: dif(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tgsyl

TGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, TGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.

  • public pure subroutine ctgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    complex(kind=sp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    complex(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(out) :: dif
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    real(kind=dp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    real(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(out) :: dif
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    real(kind=sp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    real(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(out) :: dif
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    complex(kind=dp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    complex(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(out) :: dif
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    CTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    complex(kind=sp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    complex(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(out) :: dif
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    DTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(BT, Im) ] (2) [ kron(In, D) -kron(ET, Im) ]. Here Ik is the identity matrix of size k and XT is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', DTGSYL solves the transposed system ZTy = scaleb, which is equivalent to solve for R and L in AT * R + DT * L = scale * C (3) R * BT + L * ET = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using DLACON. If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    real(kind=dp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    real(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(out) :: dif
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    STGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(BT, Im) ] (2) [ kron(In, D) -kron(ET, Im) ]. Here Ik is the identity matrix of size k and XT is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', STGSYL solves the transposed system ZTy = scaleb, which is equivalent to solve for R and L in AT * R + DT * L = scale * C (3) R * BT + L * ET = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using SLACON. If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    real(kind=sp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    real(kind=sp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=sp), intent(out) :: scale
    real(kind=sp), intent(out) :: dif
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)

    ZTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using ZLACON. If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: ijob
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(in) :: d(ldd,*)
    integer(kind=ilp), intent(in) :: ldd
    complex(kind=dp), intent(in) :: e(lde,*)
    integer(kind=ilp), intent(in) :: lde
    complex(kind=dp), intent(inout) :: f(ldf,*)
    integer(kind=ilp), intent(in) :: ldf
    real(kind=dp), intent(out) :: scale
    real(kind=dp), intent(out) :: dif
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tpcon

TPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

  • public subroutine ctpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine ztpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ctpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info)

    CTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info)

    DTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_stpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info)

    STPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ztpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info)

    ZTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tplqt

TPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

  • public pure subroutine ctplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    CTPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    DTPLQT computes a blocked LQ factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    STPLQT computes a blocked LQ factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)

    ZTPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface tplqt2

TPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

  • public pure subroutine ctplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    CTPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    DTPLQT2 computes a LQ a factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    STPLQT2 computes a LQ a factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztplqt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    ZTPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info

public interface tpmlqt

TPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

  • public pure subroutine ctpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    CTPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    DTPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    STPMLQT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    ZTPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: mb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface tpmqrt

TPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

  • public pure subroutine ctpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    CTPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    DTPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    STPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)

    ZTPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface tpqrt

TPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

  • public pure subroutine ctpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    CTPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    DTPQRT computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    STPQRT computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)

    ZTPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface tpqrt2

TPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

  • public pure subroutine ctpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    CTPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    DTPQRT2 computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    STPQRT2 computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info)

    ZTPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    integer(kind=ilp), intent(out) :: info

public interface tprfb

TPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

  • public pure subroutine ctprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine dtprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine ztprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_ctprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    CTPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_dtprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    DTPRFB applies a real "triangular-pentagonal" block reflector H or its transpose H**T to a real matrix C, which is composed of two blocks A and B, either from the left or right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_stprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    STPRFB applies a real "triangular-pentagonal" block reflector H or its conjugate transpose H^H to a real matrix C, which is composed of two blocks A and B, either from the left or right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    real(kind=sp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
  • public pure subroutine stdlib_ztprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)

    ZTPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    character, intent(in) :: direct
    character, intent(in) :: storev
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(in) :: v(ldv,*)
    integer(kind=ilp), intent(in) :: ldv
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork

public interface tprfs

TPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. TPRFS does not do iterative refinement because doing so cannot improve the backward error.

  • public pure subroutine ctprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by DTPTRS or some other means before entering this routine. DTPRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    STPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by STPTRS or some other means before entering this routine. STPRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by ZTPTRS or some other means before entering this routine. ZTPRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface tptri

TPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

  • public pure subroutine ctptri(uplo, diag, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtptri(uplo, diag, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stptri(uplo, diag, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztptri(uplo, diag, n, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctptri(uplo, diag, n, ap, info)

    CTPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtptri(uplo, diag, n, ap, info)

    DTPTRI computes the inverse of a real upper or lower triangular matrix A stored in packed format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stptri(uplo, diag, n, ap, info)

    STPTRI computes the inverse of a real upper or lower triangular matrix A stored in packed format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztptri(uplo, diag, n, ap, info)

    ZTPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    integer(kind=ilp), intent(out) :: info

public interface tptrs

TPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

  • public pure subroutine ctptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    CTPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    DTPTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    STPTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info)

    ZTPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface tpttf

TPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

  • public pure subroutine ctpttf(transr, uplo, n, ap, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(0:*)
    complex(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpttf(transr, uplo, n, ap, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(0:*)
    real(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpttf(transr, uplo, n, ap, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(0:*)
    real(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpttf(transr, uplo, n, ap, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(0:*)
    complex(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpttf(transr, uplo, n, ap, arf, info)

    CTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(0:*)
    complex(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpttf(transr, uplo, n, ap, arf, info)

    DTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(0:*)
    real(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpttf(transr, uplo, n, ap, arf, info)

    STPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(0:*)
    real(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpttf(transr, uplo, n, ap, arf, info)

    ZTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(0:*)
    complex(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info

public interface tpttr

TPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

  • public pure subroutine ctpttr(uplo, n, ap, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtpttr(uplo, n, ap, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stpttr(uplo, n, ap, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztpttr(uplo, n, ap, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctpttr(uplo, n, ap, a, lda, info)

    CTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtpttr(uplo, n, ap, a, lda, info)

    DTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: ap(*)
    real(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stpttr(uplo, n, ap, a, lda, info)

    STPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: ap(*)
    real(kind=sp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztpttr(uplo, n, ap, a, lda, info)

    ZTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(out) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface trcon

TRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

  • public subroutine ctrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtrcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine strcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine ztrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ctrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info)

    CTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: rcond
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtrcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info)

    DTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: rcond
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_strcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info)

    STRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: rcond
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ztrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info)

    ZTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: norm
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: rcond
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface trevc

TREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.

  • public pure subroutine ctrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    CTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)

    DTREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)

    STREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)

    ZTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface trevc3

TREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

  • public pure subroutine ctrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)

    CTREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)

    DTREVC3 computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yT)T = w(yT) where yT denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)

    STREVC3 computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yT)T = w(yT) where yT denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(inout) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)

    ZTREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(inout) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: info

public interface trexc

TREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.

  • public pure subroutine ctrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(in) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtrexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine strexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(in) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info)

    CTREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(in) :: ilst
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtrexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info)

    DTREXC reorders the real Schur factorization of a real matrix A = QTQT, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation ZTTZ, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_strexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info)

    STREXC reorders the real Schur factorization of a real matrix A = QTQT, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation ZTTZ, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(inout) :: ifst
    integer(kind=ilp), intent(inout) :: ilst
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info)

    ZTREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: compq
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    integer(kind=ilp), intent(in) :: ifst
    integer(kind=ilp), intent(in) :: ilst
    integer(kind=ilp), intent(out) :: info

public interface trrfs

TRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. TRRFS does not do iterative refinement because doing so cannot improve the backward error.

  • public pure subroutine ctrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    CTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    complex(kind=sp), intent(out) :: work(*)
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    DTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by DTRTRS or some other means before entering this routine. DTRRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)

    STRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by STRTRS or some other means before entering this routine. STRRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=sp), intent(out) :: ferr(*)
    real(kind=sp), intent(out) :: berr(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)

    ZTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by ZTRTRS or some other means before entering this routine. ZTRRFS does not do iterative refinement because doing so cannot improve the backward error.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(in) :: x(ldx,*)
    integer(kind=ilp), intent(in) :: ldx
    real(kind=dp), intent(out) :: ferr(*)
    real(kind=dp), intent(out) :: berr(*)
    complex(kind=dp), intent(out) :: work(*)
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface trsen

TRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

  • public subroutine ctrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: sep
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtrsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: sep
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine strsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: sep
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine ztrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: sep
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ctrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)

    CTRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: sep
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtrsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)

    DTRSEN reorders the real Schur factorization of a real matrix A = QTQ**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=dp), intent(out) :: wr(*)
    real(kind=dp), intent(out) :: wi(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: sep
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_strsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)

    STRSEN reorders the real Schur factorization of a real matrix A = QTQ**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    real(kind=sp), intent(out) :: wr(*)
    real(kind=sp), intent(out) :: wi(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: s
    real(kind=sp), intent(out) :: sep
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(in) :: liwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ztrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)

    ZTRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: compq
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(inout) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: w(*)
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: s
    real(kind=dp), intent(out) :: sep
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface trsna

TRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).

  • public pure subroutine ctrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine strsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)

    CTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)

    DTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix QTQ**T with Q orthogonal). T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_strsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)

    STRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix QTQ**T with Q orthogonal). T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    real(kind=sp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    real(kind=sp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=sp), intent(out) :: s(*)
    real(kind=sp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    real(kind=sp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)

    ZTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: job
    character, intent(in) :: howmny
    logical(kind=lk), intent(in) :: select(*)
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(in) :: vl(ldvl,*)
    integer(kind=ilp), intent(in) :: ldvl
    complex(kind=dp), intent(in) :: vr(ldvr,*)
    integer(kind=ilp), intent(in) :: ldvr
    real(kind=dp), intent(out) :: s(*)
    real(kind=dp), intent(out) :: sep(*)
    integer(kind=ilp), intent(in) :: mm
    integer(kind=ilp), intent(out) :: m
    complex(kind=dp), intent(out) :: work(ldwork,*)
    integer(kind=ilp), intent(in) :: ldwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(out) :: info

public interface trsyl

TRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

  • public subroutine ctrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine dtrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine strsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine ztrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ctrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    CTRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_dtrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    DTRSYL solves the real Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_strsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    STRSYL solves the real Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    real(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=sp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_ztrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)

    ZTRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trana
    character, intent(in) :: tranb
    integer(kind=ilp), intent(in) :: isgn
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    real(kind=dp), intent(out) :: scale
    integer(kind=ilp), intent(out) :: info

public interface trtri

TRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

  • public pure subroutine ctrtri(uplo, diag, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrtri(uplo, diag, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strtri(uplo, diag, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrtri(uplo, diag, n, a, lda, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrtri(uplo, diag, n, a, lda, info)

    CTRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrtri(uplo, diag, n, a, lda, info)

    DTRTRI computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strtri(uplo, diag, n, a, lda, info)

    STRTRI computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrtri(uplo, diag, n, a, lda, info)

    ZTRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    integer(kind=ilp), intent(out) :: info

public interface trtrs

TRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

  • public pure subroutine ctrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    CTRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    DTRTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    STRTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)

    ZTRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    character, intent(in) :: trans
    character, intent(in) :: diag
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nrhs
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(inout) :: b(ldb,*)
    integer(kind=ilp), intent(in) :: ldb
    integer(kind=ilp), intent(out) :: info

public interface trttf

TRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

  • public pure subroutine ctrttf(transr, uplo, n, a, lda, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrttf(transr, uplo, n, a, lda, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strttf(transr, uplo, n, a, lda, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrttf(transr, uplo, n, a, lda, arf, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrttf(transr, uplo, n, a, lda, arf, info)

    CTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrttf(transr, uplo, n, a, lda, arf, info)

    DTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strttf(transr, uplo, n, a, lda, arf, info)

    STRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrttf(transr, uplo, n, a, lda, arf, info)

    ZTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: transr
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(0:lda-1,0:*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: arf(0:*)
    integer(kind=ilp), intent(out) :: info

public interface trttp

TRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).

  • public pure subroutine ctrttp(uplo, n, a, lda, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtrttp(uplo, n, a, lda, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine strttp(uplo, n, a, lda, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztrttp(uplo, n, a, lda, ap, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctrttp(uplo, n, a, lda, ap, info)

    CTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtrttp(uplo, n, a, lda, ap, info)

    DTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_strttp(uplo, n, a, lda, ap, info)

    STRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztrttp(uplo, n, a, lda, ap, info)

    ZTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: ap(*)
    integer(kind=ilp), intent(out) :: info

public interface tzrzf

TZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

  • public pure subroutine ctzrzf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine dtzrzf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stzrzf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine ztzrzf(m, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ctzrzf(m, n, a, lda, tau, work, lwork, info)

    CTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_dtzrzf(m, n, a, lda, tau, work, lwork, info)

    DTZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=dp), intent(out) :: tau(*)
    real(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_stzrzf(m, n, a, lda, tau, work, lwork, info)

    STZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    real(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    real(kind=sp), intent(out) :: tau(*)
    real(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_ztzrzf(m, n, a, lda, tau, work, lwork, info)

    ZTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb

UNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine cunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: tauq2(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: tauq2(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    CUNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: tauq2(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)

    ZUNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: tauq2(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb1

UNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine cunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    CUNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    ZUNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines ZUNBDB2, ZUNBDB3, and ZUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb2

UNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine cunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    CUNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    ZUNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB3, and ZUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb3

UNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine cunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    CUNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)

    ZUNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb4

UNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

  • public subroutine cunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: phantom(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine zunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: phantom(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    CUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    real(kind=sp), intent(out) :: phi(*)
    complex(kind=sp), intent(out) :: taup1(*)
    complex(kind=sp), intent(out) :: taup2(*)
    complex(kind=sp), intent(out) :: tauq1(*)
    complex(kind=sp), intent(out) :: phantom(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)

    ZUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    real(kind=dp), intent(out) :: phi(*)
    complex(kind=dp), intent(out) :: taup1(*)
    complex(kind=dp), intent(out) :: taup2(*)
    complex(kind=dp), intent(out) :: tauq1(*)
    complex(kind=dp), intent(out) :: phantom(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb5

UNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

  • public pure subroutine cunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    CUNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    ZUNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unbdb6

UNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

  • public pure subroutine cunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    CUNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=sp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=sp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=sp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)

    ZUNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m1
    integer(kind=ilp), intent(in) :: m2
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: x1(*)
    integer(kind=ilp), intent(in) :: incx1
    complex(kind=dp), intent(inout) :: x2(*)
    integer(kind=ilp), intent(in) :: incx2
    complex(kind=dp), intent(in) :: q1(ldq1,*)
    integer(kind=ilp), intent(in) :: ldq1
    complex(kind=dp), intent(in) :: q2(ldq2,*)
    integer(kind=ilp), intent(in) :: ldq2
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface uncsd

UNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

  • public recursive subroutine cuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    complex(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine zuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    complex(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_cuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info)

    CUNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=sp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=sp), intent(out) :: theta(*)
    complex(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public recursive subroutine stdlib_zuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info)

    ZUNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    character, intent(in) :: jobv2t
    character, intent(in) :: trans
    character, intent(in) :: signs
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x12(ldx12,*)
    integer(kind=ilp), intent(in) :: ldx12
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    complex(kind=dp), intent(inout) :: x22(ldx22,*)
    integer(kind=ilp), intent(in) :: ldx22
    real(kind=dp), intent(out) :: theta(*)
    complex(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(out) :: v2t(ldv2t,*)
    integer(kind=ilp), intent(in) :: ldv2t
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface uncsd2by1

UNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

  • public subroutine cuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    complex(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine zuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    complex(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_cuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info)

    CUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=sp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=sp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=sp), intent(out) :: theta(*)
    complex(kind=sp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=sp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=sp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=sp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info
  • public subroutine stdlib_zuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info)

    ZUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: jobu1
    character, intent(in) :: jobu2
    character, intent(in) :: jobv1t
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: p
    integer(kind=ilp), intent(in) :: q
    complex(kind=dp), intent(inout) :: x11(ldx11,*)
    integer(kind=ilp), intent(in) :: ldx11
    complex(kind=dp), intent(inout) :: x21(ldx21,*)
    integer(kind=ilp), intent(in) :: ldx21
    real(kind=dp), intent(out) :: theta(*)
    complex(kind=dp), intent(out) :: u1(ldu1,*)
    integer(kind=ilp), intent(in) :: ldu1
    complex(kind=dp), intent(out) :: u2(ldu2,*)
    integer(kind=ilp), intent(in) :: ldu2
    complex(kind=dp), intent(out) :: v1t(ldv1t,*)
    integer(kind=ilp), intent(in) :: ldv1t
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    real(kind=dp), intent(out) :: rwork(*)
    integer(kind=ilp), intent(in) :: lrwork
    integer(kind=ilp), intent(out) :: iwork(*)
    integer(kind=ilp), intent(out) :: info

public interface ung2l

UNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

  • public pure subroutine cung2l(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zung2l(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cung2l(m, n, k, a, lda, tau, work, info)

    CUNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zung2l(m, n, k, a, lda, tau, work, info)

    ZUNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by ZGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface ung2r

UNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

  • public pure subroutine cung2r(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zung2r(m, n, k, a, lda, tau, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cung2r(m, n, k, a, lda, tau, work, info)

    CUNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zung2r(m, n, k, a, lda, tau, work, info)

    ZUNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface ungbr

UNGBR generates one of the complex unitary matrices Q or PH determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and UNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and UNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and UNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and UNGBR returns PH as an N-by-N matrix.

  • public pure subroutine cungbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    CUNGBR generates one of the complex unitary matrices Q or PH determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and CUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and CUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and CUNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and CUNGBR returns PH as an N-by-N matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungbr(vect, m, n, k, a, lda, tau, work, lwork, info)

    ZUNGBR generates one of the complex unitary matrices Q or PH determined by ZGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and ZUNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and ZUNGBR returns PH as an N-by-N matrix.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unghr

UNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

  • public pure subroutine cunghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    CUNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunghr(n, ilo, ihi, a, lda, tau, work, lwork, info)

    ZUNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unglq

UNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.

  • public pure subroutine cunglq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunglq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunglq(m, n, k, a, lda, tau, work, lwork, info)

    CUNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunglq(m, n, k, a, lda, tau, work, lwork, info)

    ZUNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by ZGELQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungql

UNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

  • public pure subroutine cungql(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungql(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungql(m, n, k, a, lda, tau, work, lwork, info)

    CUNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungql(m, n, k, a, lda, tau, work, lwork, info)

    ZUNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by ZGEQLF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungqr

UNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

  • public pure subroutine cungqr(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungqr(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungqr(m, n, k, a, lda, tau, work, lwork, info)

    CUNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungqr(m, n, k, a, lda, tau, work, lwork, info)

    ZUNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungrq

UNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

  • public pure subroutine cungrq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungrq(m, n, k, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungrq(m, n, k, a, lda, tau, work, lwork, info)

    CUNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungrq(m, n, k, a, lda, tau, work, lwork, info)

    ZUNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungtr

UNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

  • public pure subroutine cungtr(uplo, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungtr(uplo, n, a, lda, tau, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungtr(uplo, n, a, lda, tau, work, lwork, info)

    CUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungtr(uplo, n, a, lda, tau, work, lwork, info)

    ZUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungtsqr

UNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.

  • public pure subroutine cungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    CUNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    ZUNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by ZLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for ZLATSQR.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface ungtsqr_row

UNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.

  • public pure subroutine cungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    CUNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)

    ZUNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of ZLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by ZLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of ZLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine ZLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which ZLATSQR generates the output blocks.

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: mb
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unhr_col

UNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).

  • public pure subroutine cunhr_col(m, n, nb, a, lda, t, ldt, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunhr_col(m, n, nb, a, lda, t, ldt, d, info)

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunhr_col(m, n, nb, a, lda, t, ldt, d, info)

    CUNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=sp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunhr_col(m, n, nb, a, lda, t, ldt, d, info)

    ZUNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as ZGEQRT).

    Arguments

    TypeIntentOptionalAttributesName
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: nb
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(out) :: t(ldt,*)
    integer(kind=ilp), intent(in) :: ldt
    complex(kind=dp), intent(out) :: d(*)
    integer(kind=ilp), intent(out) :: info

public interface unm2l

UNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

  • public pure subroutine cunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    CUNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    ZUNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by ZGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface unm2r

UNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

  • public pure subroutine cunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    CUNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info)

    ZUNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface unmbr

If VECT = 'Q', UNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', UNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

  • public pure subroutine cunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    If VECT = 'Q', CUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    If VECT = 'Q', ZUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', ZUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by ZGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: vect
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmhr

UNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

  • public pure subroutine cunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    CUNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: ilo
    integer(kind=ilp), intent(in) :: ihi
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmlq

UNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    CUNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by ZGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmql

UNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    CUNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by ZGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmqr

UNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    CUNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmrq

UNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    CUNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmrz

UNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

  • public pure subroutine cunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    CUNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    integer(kind=ilp), intent(in) :: k
    integer(kind=ilp), intent(in) :: l
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface unmtr

UNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

  • public pure subroutine cunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    CUNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)

    ZUNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: a(lda,*)
    integer(kind=ilp), intent(in) :: lda
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(in) :: lwork
    integer(kind=ilp), intent(out) :: info

public interface upgtr

UPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

  • public pure subroutine cupgtr(uplo, n, ap, tau, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zupgtr(uplo, n, ap, tau, q, ldq, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cupgtr(uplo, n, ap, tau, q, ldq, work, info)

    CUPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(in) :: ap(*)
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zupgtr(uplo, n, ap, tau, q, ldq, work, info)

    ZUPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by ZHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: uplo
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(in) :: ap(*)
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(out) :: q(ldq,*)
    integer(kind=ilp), intent(in) :: ldq
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info

public interface upmtr

UPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

  • public pure subroutine cupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine zupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_cupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    CUPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=sp), intent(inout) :: ap(*)
    complex(kind=sp), intent(in) :: tau(*)
    complex(kind=sp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=sp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info
  • public pure subroutine stdlib_zupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info)

    ZUPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

    Arguments

    TypeIntentOptionalAttributesName
    character, intent(in) :: side
    character, intent(in) :: uplo
    character, intent(in) :: trans
    integer(kind=ilp), intent(in) :: m
    integer(kind=ilp), intent(in) :: n
    complex(kind=dp), intent(inout) :: ap(*)
    complex(kind=dp), intent(in) :: tau(*)
    complex(kind=dp), intent(inout) :: c(ldc,*)
    integer(kind=ilp), intent(in) :: ldc
    complex(kind=dp), intent(out) :: work(*)
    integer(kind=ilp), intent(out) :: info